From 9ae1496f112d4550af1c9d393e22e125cf60b206 Mon Sep 17 00:00:00 2001
From: "max.rabiciuc" <max.rabiciuc@robinhood.com>
Date: Wed, 22 Nov 2023 10:25:21 -0800
Subject: [PATCH 1/3] Implement Field and update traverse implementation to use
 static  _fields var

---
 Sources/SwiftProtobuf/Field.swift             | 735 ++++++++++++++++++
 Sources/SwiftProtobuf/Message.swift           |  11 +
 Sources/protoc-gen-swift/FieldGenerator.swift |   3 +
 .../MessageFieldGenerator.swift               |  28 +
 .../protoc-gen-swift/MessageGenerator.swift   |  76 +-
 Sources/protoc-gen-swift/OneofGenerator.swift |  32 +
 6 files changed, 848 insertions(+), 37 deletions(-)
 create mode 100644 Sources/SwiftProtobuf/Field.swift

diff --git a/Sources/SwiftProtobuf/Field.swift b/Sources/SwiftProtobuf/Field.swift
new file mode 100644
index 000000000..47ddb88ad
--- /dev/null
+++ b/Sources/SwiftProtobuf/Field.swift
@@ -0,0 +1,735 @@
+//
+//  Field.swift
+//  
+//
+//  Created by Max Rabiciuc on 11/14/23.
+//
+
+import Foundation
+
+/// Represents a field on a given `Message` type
+///
+/// Used to enable `Visitor` traversal of messages
+public struct Field<M: Message> {
+
+    private let field: any FieldItem<M>
+    private let fieldNumber: Int
+    private let isDefault: (M) -> Bool
+    
+    /// Traveses the given message instance using the given visitor
+    internal func traverse<V: Visitor>(message: M, visitor: inout V) throws {
+        if !isDefault(message) {
+            try field.traverse(message: message, fieldNumber: fieldNumber, visitor: &visitor)
+        }
+    }
+    
+    public static func singularFloat(_ getValue: @escaping (M) -> Float, fieldNumber: Int, defaultValue: Float = 0) -> Self {
+        Self(field: SingularFloatField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularFloat(_ getValue: @escaping (M) -> Float, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularFloatField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularDouble(_ getValue: @escaping (M) -> Double, fieldNumber: Int, defaultValue: Double = 0) -> Self {
+        Self(field: SingularDoubleField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularDouble(_ getValue: @escaping (M) -> Double, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularDoubleField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularInt32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, defaultValue: Int32 = 0) -> Self {
+        Self(field: SingularInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularInt32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularInt64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, defaultValue: Int64 = 0) -> Self {
+        Self(field: SingularInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularInt64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularUInt32(_ getValue: @escaping (M) -> UInt32, fieldNumber: Int, defaultValue: UInt32 = 0) -> Self {
+        Self(field: SingularUInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularUInt32(_ getValue: @escaping (M) -> UInt32, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularUInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularUInt64(_ getValue: @escaping (M) -> UInt64, fieldNumber: Int, defaultValue: UInt64 = 0) -> Self {
+        Self(field: SingularUInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularUInt64(_ getValue: @escaping (M) -> UInt64, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularUInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularSInt32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, defaultValue: Int32 = 0) -> Self {
+        Self(field: SingularSInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularSInt32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularSInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularSInt64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, defaultValue: Int64 = 0) -> Self {
+        Self(field: SingularSInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularSInt64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularSInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularFixed32(_ getValue: @escaping (M) -> UInt32, fieldNumber: Int, defaultValue: UInt32 = 0) -> Self {
+        Self(field: SingularFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularFixed32(_ getValue: @escaping (M) -> UInt32, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularFixed64(_ getValue: @escaping (M) -> UInt64, fieldNumber: Int, defaultValue: UInt64 = 0) -> Self {
+        Self(field: SingularFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularFixed64(_ getValue: @escaping (M) -> UInt64, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularSFixed32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, defaultValue: Int32 = 0) -> Self {
+        Self(field: SingularSFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularSFixed32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularSFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularSFixed64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, defaultValue: Int64 = 0) -> Self {
+        Self(field: SingularSFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularSFixed64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularSFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularBool(_ getValue: @escaping (M) -> Bool, fieldNumber: Int, defaultValue: Bool = false) -> Self {
+        Self(field: SingularBoolField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularBool(_ getValue: @escaping (M) -> Bool, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularBoolField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularString(_ getValue: @escaping (M) -> String, fieldNumber: Int, defaultValue: String = "") -> Self {
+        Self(field: SingularStringField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularString(_ getValue: @escaping (M) -> String, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularStringField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    public static func singularBytes(_ getValue: @escaping (M) -> Data, fieldNumber: Int, defaultValue: Data = Data()) -> Self {
+        Self(field: SingularBytesField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularBytes(_ getValue: @escaping (M) -> Data, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularBytesField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+
+    public static func repeatedFloat(_ getValue: @escaping (M) -> [Float], fieldNumber: Int) -> Self {
+        Self(field: RepeatedFloatField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedDouble(_ getValue: @escaping (M) -> [Double], fieldNumber: Int) -> Self {
+        Self(field: RepeatedDoubleField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedInt32(_ getValue: @escaping (M) -> [Int32], fieldNumber: Int) -> Self {
+        Self(field: RepeatedInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedInt64(_ getValue: @escaping (M) -> [Int64], fieldNumber: Int) -> Self {
+        Self(field: RepeatedInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedUInt32(_ getValue: @escaping (M) -> [UInt32], fieldNumber: Int) -> Self {
+        Self(field: RepeatedUInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedUInt64(_ getValue: @escaping (M) -> [UInt64], fieldNumber: Int) -> Self {
+        Self(field: RepeatedUInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedSInt32(_ getValue: @escaping (M) -> [Int32], fieldNumber: Int) -> Self {
+        Self(field: RepeatedSInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedSInt64(_ getValue: @escaping (M) -> [Int64], fieldNumber: Int) -> Self {
+        Self(field: RepeatedSInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedFixed32(_ getValue: @escaping (M) -> [UInt32], fieldNumber: Int) -> Self {
+        Self(field: RepeatedFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedFixed64(_ getValue: @escaping (M) -> [UInt64], fieldNumber: Int) -> Self {
+        Self(field: RepeatedFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedSFixed32(_ getValue: @escaping (M) -> [Int32], fieldNumber: Int) -> Self {
+        Self(field: RepeatedSFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedSFixed64(_ getValue: @escaping (M) -> [Int64], fieldNumber: Int) -> Self {
+        Self(field: RepeatedSFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedBool(_ getValue: @escaping (M) -> [Bool], fieldNumber: Int) -> Self {
+        Self(field: RepeatedBoolField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedString(_ getValue: @escaping (M) -> [String], fieldNumber: Int) -> Self {
+        Self(field: RepeatedStringField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedBytes(_ getValue: @escaping (M) -> [Data], fieldNumber: Int) -> Self {
+        Self(field: RepeatedBytesField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedFloat(_ getValue: @escaping (M) -> [Float], fieldNumber: Int) -> Self {
+        Self(field: PackedFloatField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedDouble(_ getValue: @escaping (M) -> [Double], fieldNumber: Int) -> Self {
+        Self(field: PackedDoubleField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedInt32(_ getValue: @escaping (M) -> [Int32], fieldNumber: Int) -> Self {
+        Self(field: PackedInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedInt64(_ getValue: @escaping (M) -> [Int64], fieldNumber: Int) -> Self {
+        Self(field: PackedInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedUInt32(_ getValue: @escaping (M) -> [UInt32], fieldNumber: Int) -> Self {
+        Self(field: PackedUInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedUInt64(_ getValue: @escaping (M) -> [UInt64], fieldNumber: Int) -> Self {
+        Self(field: PackedUInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedSInt32(_ getValue: @escaping (M) -> [Int32], fieldNumber: Int) -> Self {
+        Self(field: PackedSInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedSInt64(_ getValue: @escaping (M) -> [Int64], fieldNumber: Int) -> Self {
+        Self(field: PackedSInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedFixed32(_ getValue: @escaping (M) -> [UInt32], fieldNumber: Int) -> Self {
+        Self(field: PackedFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedFixed64(_ getValue: @escaping (M) -> [UInt64], fieldNumber: Int) -> Self {
+        Self(field: PackedFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedSFixed32(_ getValue: @escaping (M) -> [Int32], fieldNumber: Int) -> Self {
+        Self(field: PackedSFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedSFixed64(_ getValue: @escaping (M) -> [Int64], fieldNumber: Int) -> Self {
+        Self(field: PackedSFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedBool(_ getValue: @escaping (M) -> [Bool], fieldNumber: Int) -> Self {
+        Self(field: PackedBoolField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+    
+    public static func singularEnum<E: Enum>(_ getValue: @escaping (M) -> E, fieldNumber: Int, defaultValue: E) -> Self {
+        Self(field: SingularEnumField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
+    }
+
+    public static func singularEnum<E: Enum>(_ getValue: @escaping (M) -> E, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularEnumField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+
+    public static func singularMessage<MessageType: Message>(_ getValue: @escaping (M) -> MessageType, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularMessageField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+    
+    public static func singularGroup<MessageType: Message>(_ getValue: @escaping (M) -> MessageType, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+        Self(field: SingularGroupField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    }
+
+    public static func repeatedEnum<E: Enum>(_ getValue: @escaping (M) -> [E], fieldNumber: Int) -> Self {
+        Self(field: RepeatedEnumField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func packedEnum<E: Enum>(_ getValue: @escaping (M) -> [E], fieldNumber: Int) -> Self {
+        Self(field: PackedEnumField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+
+    public static func repeatedMessage<MessageType: Message>(_ getValue: @escaping (M) -> [MessageType], fieldNumber: Int) -> Self {
+        Self(field: RepeatedMessageField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+    
+    public static func repeatedGroup<MessageType: Message>(_ getValue: @escaping (M) -> [MessageType], fieldNumber: Int) -> Self {
+        Self(field: RepeatedGroupField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+    
+    public static func map<KeyType, ValueType: MapValueType>(type: _ProtobufMap<KeyType, ValueType>.Type, _ getValue: @escaping (M) -> [KeyType.BaseType: ValueType.BaseType], fieldNumber: Int) -> Self {
+        Self(field: MapField(fieldType: type, getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+    
+    public static func map<KeyType, ValueType: Enum>(type: _ProtobufEnumMap<KeyType, ValueType>.Type, _ getValue: @escaping (M) -> [KeyType.BaseType: ValueType], fieldNumber: Int) -> Self where ValueType.RawValue == Int {
+        Self(field: EnumMapField(fieldType: type, getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+    
+    public static func map<KeyType, ValueType: Message & Hashable>(type: _ProtobufMessageMap<KeyType, ValueType>.Type, _ getValue: @escaping (M) -> [KeyType.BaseType: ValueType], fieldNumber: Int) -> Self {
+        Self(field: MessageMapField(fieldType: type, getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0).isEmpty })
+    }
+    
+    public static func oneOf<T>(_ getValue: @escaping (M) -> T?, toConcrete: @escaping (T) -> Field<M>?) -> Self {
+        Self(field: OneOfField(getValue: getValue, toConcrete: toConcrete), fieldNumber: .max, isDefault: { getValue($0) == nil })
+    }
+    
+    public static func extensionFields(_ getValue: @escaping (M) -> ExtensionFieldValueSet, start: Int, end: Int) -> Self {
+        Self(field: ExtensionFieldsItem(getValue: getValue, start: start, end: end), fieldNumber: .max, isDefault: { _ in false })
+    }
+    
+    public static func extensionFieldsAsMessageSet(_ getValue: @escaping (M) -> ExtensionFieldValueSet, start: Int, end: Int) -> Self {
+        Self(field: ExtensionFieldsAsMessageSetItem(getValue: getValue, start: start, end: end), fieldNumber: .max, isDefault: { _ in false })
+    }
+}
+
+private protocol FieldItem<M> {
+    associatedtype M: Message
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws
+}
+
+fileprivate struct ExtensionFieldsItem<M: Message>: FieldItem {
+    let getValue: (M) -> ExtensionFieldValueSet
+    let start: Int
+    let end: Int
+
+    func traverse<V>(message: M, fieldNumber: Int, visitor: inout V) throws where V : Visitor {
+        try visitor.visitExtensionFields(fields: getValue(message), start: start, end: end)
+    }
+}
+
+fileprivate struct ExtensionFieldsAsMessageSetItem<M: Message>: FieldItem {
+    let getValue: (M) -> ExtensionFieldValueSet
+    let start: Int
+    let end: Int
+
+    func traverse<V>(message: M, fieldNumber: Int, visitor: inout V) throws where V : Visitor {
+        try visitor.visitExtensionFieldsAsMessageSet(fields: getValue(message), start: start, end: end)
+    }
+}
+
+fileprivate struct OneOfField<M: Message, T>: FieldItem {
+    let getValue: (M) -> T?
+    let toConcrete: (T) -> Field<M>?
+    
+    func traverse<V>(message: M, fieldNumber: Int, visitor: inout V) throws where V : Visitor {
+        guard let value = getValue(message) else {
+            return
+        }
+        try toConcrete(value)?.traverse(message: message, visitor: &visitor)
+    }
+}
+
+fileprivate struct MapField<M: Message, KeyType: MapKeyType, ValueType: MapValueType>: FieldItem {
+    let fieldType: _ProtobufMap<KeyType, ValueType>.Type
+    let getValue: (M) -> [KeyType.BaseType: ValueType.BaseType]
+
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitMapField(fieldType: fieldType, value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct EnumMapField<M: Message, KeyType: MapKeyType, ValueType: Enum>: FieldItem where ValueType.RawValue == Int {
+    let fieldType: _ProtobufEnumMap<KeyType, ValueType>.Type
+    let getValue: (M) -> [KeyType.BaseType: ValueType]
+
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitMapField(fieldType: fieldType, value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct MessageMapField<M: Message, KeyType: MapKeyType, ValueType: Message & Hashable>: FieldItem {
+    let fieldType: _ProtobufMessageMap<KeyType, ValueType>.Type
+    let getValue: (M) -> [KeyType.BaseType: ValueType]
+
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitMapField(fieldType: fieldType, value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct SingularFloatField<M: Message>: FieldItem {
+    let getValue: (M) -> Float
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularFloatField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularDoubleField<M: Message>: FieldItem {
+    let getValue: (M) -> Double
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularDoubleField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularInt32Field<M: Message>: FieldItem {
+    let getValue: (M) -> Int32
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularInt32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularInt64Field<M: Message>: FieldItem {
+    let getValue: (M) -> Int64
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularInt64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularUInt32Field<M: Message>: FieldItem {
+    let getValue: (M) -> UInt32
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularUInt32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularUInt64Field<M: Message>: FieldItem {
+    let getValue: (M) -> UInt64
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularUInt64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularSInt32Field<M: Message>: FieldItem {
+    let getValue: (M) -> Int32
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularSInt32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularSInt64Field<M: Message>: FieldItem {
+    let getValue: (M) -> Int64
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularSInt64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularFixed32Field<M: Message>: FieldItem {
+    let getValue: (M) -> UInt32
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularFixed32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularFixed64Field<M: Message>: FieldItem {
+    let getValue: (M) -> UInt64
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularFixed64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularSFixed32Field<M: Message>: FieldItem {
+    let getValue: (M) -> Int32
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularSFixed32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularSFixed64Field<M: Message>: FieldItem {
+    let getValue: (M) -> Int64
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularSFixed64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularBoolField<M: Message>: FieldItem {
+    let getValue: (M) -> Bool
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularBoolField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularStringField<M: Message>: FieldItem {
+    let getValue: (M) -> String
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularStringField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct SingularBytesField<M: Message>: FieldItem {
+    let getValue: (M) -> Data
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularBytesField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedFloatField<M: Message>: FieldItem {
+    let getValue: (M) -> [Float]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedFloatField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedDoubleField<M: Message>: FieldItem {
+    let getValue: (M) -> [Double]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedDoubleField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedInt32Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int32]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedInt32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedInt64Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int64]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedInt64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedUInt32Field<M: Message>: FieldItem {
+    let getValue: (M) -> [UInt32]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedUInt32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedUInt64Field<M: Message>: FieldItem {
+    let getValue: (M) -> [UInt64]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedUInt64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedSInt32Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int32]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedSInt32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedSInt64Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int64]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedSInt64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedFixed32Field<M: Message>: FieldItem {
+    let getValue: (M) -> [UInt32]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedFixed32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedFixed64Field<M: Message>: FieldItem {
+    let getValue: (M) -> [UInt64]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedFixed64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedSFixed32Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int32]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedSFixed32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedSFixed64Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int64]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedSFixed64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedBoolField<M: Message>: FieldItem {
+    let getValue: (M) -> [Bool]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedBoolField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedStringField<M: Message>: FieldItem {
+    let getValue: (M) -> [String]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedStringField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct RepeatedBytesField<M: Message>: FieldItem {
+    let getValue: (M) -> [Data]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedBytesField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+fileprivate struct PackedFloatField<M: Message>: FieldItem {
+    let getValue: (M) -> [Float]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedFloatField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedDoubleField<M: Message>: FieldItem {
+    let getValue: (M) -> [Double]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedDoubleField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedInt32Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int32]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedInt32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedInt64Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int64]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedInt64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedUInt32Field<M: Message>: FieldItem {
+    let getValue: (M) -> [UInt32]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedUInt32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedUInt64Field<M: Message>: FieldItem {
+    let getValue: (M) -> [UInt64]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedUInt64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedSInt32Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int32]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedSInt32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedSInt64Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int64]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedSInt64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedFixed32Field<M: Message>: FieldItem {
+    let getValue: (M) -> [UInt32]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedFixed32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedFixed64Field<M: Message>: FieldItem {
+    let getValue: (M) -> [UInt64]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedFixed64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedSFixed32Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int32]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedSFixed32Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedSFixed64Field<M: Message>: FieldItem {
+    let getValue: (M) -> [Int64]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedSFixed64Field(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedBoolField<M: Message>: FieldItem {
+    let getValue: (M) -> [Bool]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedBoolField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct SingularMessageField<M: Message, F: Message>: FieldItem {
+    let getValue: (M) -> F
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularMessageField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct SingularGroupField<M: Message, F: Message>: FieldItem {
+    let getValue: (M) -> F
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularGroupField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+
+fileprivate struct RepeatedMessageField<M: Message, F: Message>: FieldItem {
+    let getValue: (M) -> [F]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedMessageField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct RepeatedGroupField<M: Message, F: Message>: FieldItem {
+    let getValue: (M) -> [F]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedGroupField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+
+fileprivate struct SingularEnumField<M: Message, F: Enum>: FieldItem {
+    let getValue: (M) -> F
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitSingularEnumField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct RepeatedEnumField<M: Message, E: Enum>: FieldItem {
+    let getValue: (M) -> [E]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitRepeatedEnumField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
+
+fileprivate struct PackedEnumField<M: Message, E: Enum>: FieldItem {
+    let getValue: (M) -> [E]
+    
+    func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
+        try visitor.visitPackedEnumField(value: getValue(message), fieldNumber: fieldNumber)
+    }
+}
diff --git a/Sources/SwiftProtobuf/Message.swift b/Sources/SwiftProtobuf/Message.swift
index b619acfd3..af5031d6a 100644
--- a/Sources/SwiftProtobuf/Message.swift
+++ b/Sources/SwiftProtobuf/Message.swift
@@ -110,6 +110,9 @@ public protocol Message: _CommonMessageConformances {
   /// normal `Equatable`. `Equatable` is provided with specific generated
   /// types.
   func isEqualTo(message: any Message) -> Bool
+    
+  /// Provides `Field` information for this `Message` type used to provide a default implementation of `traverse`
+  static var _fields: [Field<Self>] { get }
 }
 
 #if DEBUG
@@ -129,6 +132,14 @@ extension Message {
     return true
   }
 
+  /// Default traverse implementation
+  public func traverse<V: Visitor>(visitor: inout V) throws {
+    for field in Self._fields {
+      try field.traverse(message: self, visitor: &visitor)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
   /// A hash based on the message's full contents.
   public func hash(into hasher: inout Hasher) {
     var visitor = HashVisitor(hasher)
diff --git a/Sources/protoc-gen-swift/FieldGenerator.swift b/Sources/protoc-gen-swift/FieldGenerator.swift
index 505adacba..ae84ff92a 100644
--- a/Sources/protoc-gen-swift/FieldGenerator.swift
+++ b/Sources/protoc-gen-swift/FieldGenerator.swift
@@ -44,6 +44,9 @@ protocol FieldGenerator {
 
   /// Generate the support for traversing this field.
   func generateTraverse(printer: inout CodePrinter)
+  
+  /// Generate the field node
+  func generateFieldNode(printer: inout CodePrinter)
 
   /// Generate support for comparing this field's value.
   /// The generated code should return false in the current scope if the field's don't match.
diff --git a/Sources/protoc-gen-swift/MessageFieldGenerator.swift b/Sources/protoc-gen-swift/MessageFieldGenerator.swift
index e91c94865..1242f5ca1 100644
--- a/Sources/protoc-gen-swift/MessageFieldGenerator.swift
+++ b/Sources/protoc-gen-swift/MessageFieldGenerator.swift
@@ -26,6 +26,7 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator {
     private let swiftName: String
     private let underscoreSwiftName: String
     private let storedProperty: String
+    private let storedPropertyWithoutSelf: String
     private let swiftHasName: String
     private let swiftClearName: String
     private let swiftType: String
@@ -75,8 +76,10 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator {
 
         if usesHeapStorage {
             storedProperty = "_storage.\(underscoreSwiftName)"
+            storedPropertyWithoutSelf = storedProperty
         } else {
             storedProperty = "self.\(hasFieldPresence ? underscoreSwiftName : swiftName)"
+            storedPropertyWithoutSelf = "\(hasFieldPresence ? underscoreSwiftName : swiftName)"
         }
 
         super.init(descriptor: descriptor)
@@ -221,4 +224,29 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator {
         p.printIndented("try visitor.\(visitMethod)(\(traitsArg)value: \(varName), fieldNumber: \(number))")
         p.print("}\(suffix)")
     }
+  
+    func generateFieldNode(printer p: inout SwiftProtobufPluginLibrary.CodePrinter) {
+      let factoryMethod: String
+      let traitsArg: String
+      if isMap {
+          factoryMethod = "map"
+          traitsArg = "type: \(traitsType).self, "
+      } else {
+          let modifier = isPacked ? "packed" : isRepeated ? "repeated" : "singular"
+          factoryMethod = "\(modifier)\(fieldDescriptor.protoGenericType)"
+          traitsArg = ""
+      }
+      
+      let suffix: String
+      if isRepeated {
+        suffix = ""
+      } else if hasFieldPresence {
+        suffix = ", isUnset: { $0.\(storedPropertyWithoutSelf) == nil }"
+      } else if swiftDefaultValue != "0" && swiftDefaultValue != "false" && swiftDefaultValue != "String()" && swiftDefaultValue != "Data()" {
+        suffix = ", defaultValue: \(swiftDefaultValue)"
+      } else {
+        suffix = ""
+      }
+      p.print(".\(factoryMethod)(\(traitsArg){ $0.\(swiftName) }, fieldNumber: \(number)\(suffix)),")
+    }
 }
diff --git a/Sources/protoc-gen-swift/MessageGenerator.swift b/Sources/protoc-gen-swift/MessageGenerator.swift
index 9ef1a9729..00b73b9bf 100644
--- a/Sources/protoc-gen-swift/MessageGenerator.swift
+++ b/Sources/protoc-gen-swift/MessageGenerator.swift
@@ -217,6 +217,8 @@ class MessageGenerator {
       // generateIsInitialized provides a blank line after itself.
       generateDecodeMessage(printer: &p)
       p.print()
+      generateFieldNodes(printer: &p)
+      p.print()
       generateTraverse(printer: &p)
       p.print()
       generateMessageEquality(printer: &p)
@@ -311,53 +313,53 @@ class MessageGenerator {
             p.print("}")
           }
         }
-
       }
     }
     p.print("}")
   }
 
-  /// Generates the `traverse` method for the message.
-  ///
-  /// - Parameter p: The code printer.
-  private func generateTraverse(printer p: inout CodePrinter) {
-    p.print("\(visibility)func traverse<V: \(namer.swiftProtobufModulePrefix)Visitor>(visitor: inout V) throws {")
-    p.withIndentation { p in
-      generateWithLifetimeExtension(printer: &p, throws: true) { p in
-        if let storage = storage {
-          storage.generatePreTraverse(printer: &p)
-        }
+  private func generateFieldNodes(printer p: inout CodePrinter) {
+    let visitExtensionsName = descriptor.useMessageSetWireFormat ? "extensionFieldsAsMessageSet" : "extensionFields"
 
-        let visitExtensionsName =
-          descriptor.useMessageSetWireFormat ? "visitExtensionFieldsAsMessageSet" : "visitExtensionFields"
-
-        let usesLocals = fields.reduce(false) { $0 || $1.generateTraverseUsesLocals }
-        if usesLocals {
-          p.print("""
-            // The use of inline closures is to circumvent an issue where the compiler
-            // allocates stack space for every if/case branch local when no optimizations
-            // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-            // https://github.com/apple/swift-protobuf/issues/1182
-            """)
-        }
+    p.print("\(visibility)static let _fields: [Field<Self>] = [")
+      
+    // Use the "ambitious" ranges because for visit because subranges with no
+    // intermixed fields can be merged to reduce the number of calls for
+    // extension visitation.
+    var ranges = descriptor.ambitiousExtensionRanges.makeIterator()
+    var nextRange = ranges.next()
 
-        // Use the "ambitious" ranges because for visit because subranges with no
-        // intermixed fields can be merged to reduce the number of calls for
-        // extension visitation.
-        var ranges = descriptor.ambitiousExtensionRanges.makeIterator()
-        var nextRange = ranges.next()
-        for f in fieldsSortedByNumber {
-          while nextRange != nil && Int(nextRange!.lowerBound) < f.number {
-            p.print("try visitor.\(visitExtensionsName)(fields: _protobuf_extensionFieldValues, start: \(nextRange!.lowerBound), end: \(nextRange!.upperBound))")
-            nextRange = ranges.next()
-          }
-          f.generateTraverse(printer: &p)
-        }
-        while nextRange != nil {
-          p.print("try visitor.\(visitExtensionsName)(fields: _protobuf_extensionFieldValues, start: \(nextRange!.lowerBound), end: \(nextRange!.upperBound))")
+    p.withIndentation { p in
+      for f in fieldsSortedByNumber {
+        while nextRange != nil && Int(nextRange!.lowerBound) < f.number {
+          p.print(".\(visitExtensionsName)({ $0._protobuf_extensionFieldValues }, start: \(nextRange!.lowerBound), end: \(nextRange!.upperBound)),")
           nextRange = ranges.next()
         }
+        f.generateFieldNode(printer: &p)
+      }
+      while nextRange != nil {
+        p.print(".\(visitExtensionsName)({ $0._protobuf_extensionFieldValues }, start: \(nextRange!.lowerBound), end: \(nextRange!.upperBound)),")
+        nextRange = ranges.next()
       }
+    }
+    p.print("]")
+      
+    for oneof in oneofs {
+      oneof.generateFieldNodeStaticLet(printer: &p)
+    }
+  }
+    
+  private func generateTraverse(printer p: inout CodePrinter) {
+    // If we have an AnyMessageStorageClass we need to generate the traverse function so it can include a preTraverse call
+    guard let storage, storage is AnyMessageStorageClassGenerator else {
+      return
+    }
+    p.print("\(visibility)func traverse<V: Visitor>(visitor: inout V) throws {")
+    p.withIndentation { p in
+      p.print("try _storage.preTraverse()")
+      p.print("for field in Self._fields {")
+      p.printIndented("try field.traverse(message: self, visitor: &visitor)")
+      p.print("}")
       p.print("try unknownFields.traverse(visitor: &visitor)")
     }
     p.print("}")
diff --git a/Sources/protoc-gen-swift/OneofGenerator.swift b/Sources/protoc-gen-swift/OneofGenerator.swift
index 5c78b5bcd..7402bf919 100644
--- a/Sources/protoc-gen-swift/OneofGenerator.swift
+++ b/Sources/protoc-gen-swift/OneofGenerator.swift
@@ -104,6 +104,11 @@ class OneofGenerator {
         func generateTraverse(printer p: inout CodePrinter) {
             oneof.generateTraverse(printer: &p, field: self)
         }
+      
+      func generateFieldNode(printer p: inout SwiftProtobufPluginLibrary.CodePrinter) {
+          oneof.generateFieldNode(printer: &p, field: self)
+      }
+
     }
 
     private let oneofDescriptor: OneofDescriptor
@@ -360,6 +365,33 @@ class OneofGenerator {
     }
 
     var generateTraverseUsesLocals: Bool { return true }
+    
+    func generateFieldNode(printer p: inout CodePrinter, field: MemberFieldGenerator) {
+        // First field in the group causes the output.
+        let group = fieldSortedGrouped[field.group]
+        guard field === group.first else { return }
+        p.print(".oneOf({ $0.\(swiftFieldName) }) {")
+        p.withIndentation { p in
+            p.print("switch $0 {")
+            for field in group {
+                p.print("case \(field.dottedSwiftName):")
+                p.printIndented("return _oneOfField_\(field.swiftName)")
+            }
+            if group.count != fields.count {
+                p.print("default:")
+                p.printIndented("return nil")
+            }
+            p.print("}")
+        }
+        p.print("},")
+    }
+    
+    func generateFieldNodeStaticLet(printer p: inout CodePrinter) {
+        for field in fieldsSortedByNumber {
+            p.print("private static let _oneOfField_\(field.swiftName): Field<Self> = .singular\(field.protoGenericType)({ $0.\(field.swiftName) }, fieldNumber: \(field.number), isUnset: { _ in false })")
+        }
+        
+    }
 
     func generateTraverse(printer p: inout CodePrinter, field: MemberFieldGenerator) {
         // First field in the group causes the output.

From 23cadb6ac4242b99dd49c8d244583db8fec7e167 Mon Sep 17 00:00:00 2001
From: "max.rabiciuc" <max.rabiciuc@robinhood.com>
Date: Wed, 22 Nov 2023 10:25:37 -0800
Subject: [PATCH 2/3] run make regenerate

---
 .../Sources/FuzzCommon/fuzz_testing.pb.swift  |  1253 +-
 .../generated_swift_names_enum_cases.proto    |  1418 +-
 .../generated_swift_names_enums.proto         |    58 +
 .../generated_swift_names_fields.proto        |  1418 +-
 .../generated_swift_names_messages.proto      |    58 +
 Sources/Conformance/conformance.pb.swift      |   176 +-
 .../Conformance/test_messages_proto2.pb.swift |  1012 +-
 .../Conformance/test_messages_proto3.pb.swift |   695 +-
 Sources/SwiftProtobuf/any.pb.swift            |    16 +-
 Sources/SwiftProtobuf/api.pb.swift            |    86 +-
 Sources/SwiftProtobuf/descriptor.pb.swift     |   990 +-
 Sources/SwiftProtobuf/duration.pb.swift       |    14 +-
 Sources/SwiftProtobuf/empty.pb.swift          |     6 +-
 Sources/SwiftProtobuf/field_mask.pb.swift     |    10 +-
 Sources/SwiftProtobuf/source_context.pb.swift |    10 +-
 Sources/SwiftProtobuf/struct.pb.swift         |    79 +-
 Sources/SwiftProtobuf/timestamp.pb.swift      |    14 +-
 Sources/SwiftProtobuf/type.pb.swift           |   154 +-
 Sources/SwiftProtobuf/wrappers.pb.swift       |    90 +-
 .../plugin.pb.swift                           |   112 +-
 .../swift_protobuf_module_mappings.pb.swift   |    24 +-
 Tests/SwiftProtobufTests/Test_Any.swift       |     7 +-
 Tests/SwiftProtobufTests/any_test.pb.swift    |    26 +-
 .../SwiftProtobufTests/fuzz_testing.pb.swift  |  1253 +-
 .../generated_swift_names_enum_cases.pb.swift |  5733 +++----
 .../generated_swift_names_enums.pb.swift      |  3802 +++--
 .../generated_swift_names_fields.pb.swift     |  7194 ++++-----
 .../generated_swift_names_messages.pb.swift   | 12316 ++++++++--------
 .../map_proto2_unittest.pb.swift              |   124 +-
 .../SwiftProtobufTests/map_unittest.pb.swift  |   104 +-
 .../test_messages_proto3.pb.swift             |   513 +-
 Tests/SwiftProtobufTests/unittest.pb.swift    |  1251 +-
 .../unittest_import.pb.swift                  |    14 +-
 .../unittest_import_public.pb.swift           |    14 +-
 .../SwiftProtobufTests/unittest_mset.pb.swift |    78 +-
 .../unittest_mset_wire_format.pb.swift        |     8 +-
 .../unittest_preserve_unknown_enum.pb.swift   |    94 +-
 .../unittest_preserve_unknown_enum2.pb.swift  |    47 +-
 .../unittest_proto3.pb.swift                  |   425 +-
 .../unittest_proto3_optional.pb.swift         |   110 +-
 ...unittest_swift_all_required_types.pb.swift |   291 +-
 .../unittest_swift_cycle.pb.swift             |    72 +-
 .../unittest_swift_deprecated.pb.swift        |    64 +-
 .../unittest_swift_deprecated_file.pb.swift   |    22 +-
 ...ttest_swift_enum_optional_default.pb.swift |    40 +-
 .../unittest_swift_enum_proto2.pb.swift       |    32 +-
 .../unittest_swift_enum_proto3.pb.swift       |    32 +-
 .../unittest_swift_extension.pb.swift         |    96 +-
 .../unittest_swift_extension2.pb.swift        |    34 +-
 .../unittest_swift_extension3.pb.swift        |    34 +-
 .../unittest_swift_extension4.pb.swift        |    34 +-
 .../unittest_swift_fieldorder.pb.swift        |   206 +-
 .../unittest_swift_groups.pb.swift            |   144 +-
 .../unittest_swift_json.pb.swift              |    10 +-
 .../unittest_swift_naming.pb.swift            |  4327 ++----
 .../unittest_swift_naming_no_prefix.pb.swift  |     8 +-
 ...ittest_swift_naming_number_prefix.pb.swift |    14 +-
 ...unittest_swift_oneof_all_required.pb.swift |    91 +-
 .../unittest_swift_oneof_merging.pb.swift     |    99 +-
 .../unittest_swift_reserved.pb.swift          |    70 +-
 .../unittest_swift_reserved_ext.pb.swift      |     6 +-
 .../unittest_swift_runtime_proto2.pb.swift    |   475 +-
 .../unittest_swift_runtime_proto3.pb.swift    |   410 +-
 .../unittest_well_known_types.pb.swift        |   391 +-
 64 files changed, 21557 insertions(+), 26251 deletions(-)

diff --git a/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift b/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift
index 241215849..ff5a7894f 100644
--- a/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift
+++ b/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift
@@ -3852,862 +3852,325 @@ extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._singularInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._singularInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._singularUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._singularUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._singularSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._singularSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._singularFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._singularFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._singularSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._singularSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._singularFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._singularDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._singularBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._singularString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._singularBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._singularEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._singularGroup {
-        try visitor.visitSingularGroupField(value: v, fieldNumber: 17)
-      } }()
-      try { if let v = _storage._singularMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 19)
-      } }()
-      if !_storage._repeatedInt32.isEmpty {
-        try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31)
-      }
-      if !_storage._repeatedInt64.isEmpty {
-        try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32)
-      }
-      if !_storage._repeatedUint32.isEmpty {
-        try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33)
-      }
-      if !_storage._repeatedUint64.isEmpty {
-        try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34)
-      }
-      if !_storage._repeatedSint32.isEmpty {
-        try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35)
-      }
-      if !_storage._repeatedSint64.isEmpty {
-        try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36)
-      }
-      if !_storage._repeatedFixed32.isEmpty {
-        try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37)
-      }
-      if !_storage._repeatedFixed64.isEmpty {
-        try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38)
-      }
-      if !_storage._repeatedSfixed32.isEmpty {
-        try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39)
-      }
-      if !_storage._repeatedSfixed64.isEmpty {
-        try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40)
-      }
-      if !_storage._repeatedFloat.isEmpty {
-        try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41)
-      }
-      if !_storage._repeatedDouble.isEmpty {
-        try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42)
-      }
-      if !_storage._repeatedBool.isEmpty {
-        try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43)
-      }
-      if !_storage._repeatedString.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44)
-      }
-      if !_storage._repeatedBytes.isEmpty {
-        try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45)
-      }
-      if !_storage._repeatedEnum.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._repeatedEnum, fieldNumber: 46)
-      }
-      if !_storage._repeatedGroup.isEmpty {
-        try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 47)
-      }
-      if !_storage._repeatedMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedMessage, fieldNumber: 49)
-      }
-      switch _storage._o {
-      case .oneofInt32?: try {
-        guard case .oneofInt32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 61)
-      }()
-      case .oneofInt64?: try {
-        guard case .oneofInt64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 62)
-      }()
-      case .oneofUint32?: try {
-        guard case .oneofUint32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63)
-      }()
-      case .oneofUint64?: try {
-        guard case .oneofUint64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64)
-      }()
-      case .oneofSint32?: try {
-        guard case .oneofSint32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65)
-      }()
-      case .oneofSint64?: try {
-        guard case .oneofSint64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66)
-      }()
-      case .oneofFixed32?: try {
-        guard case .oneofFixed32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67)
-      }()
-      case .oneofFixed64?: try {
-        guard case .oneofFixed64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68)
-      }()
-      case .oneofSfixed32?: try {
-        guard case .oneofSfixed32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69)
-      }()
-      case .oneofSfixed64?: try {
-        guard case .oneofSfixed64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70)
-      }()
-      case .oneofFloat?: try {
-        guard case .oneofFloat(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 71)
-      }()
-      case .oneofDouble?: try {
-        guard case .oneofDouble(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 72)
-      }()
-      case .oneofBool?: try {
-        guard case .oneofBool(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 73)
-      }()
-      case .oneofString?: try {
-        guard case .oneofString(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularStringField(value: v, fieldNumber: 74)
-      }()
-      case .oneofBytes?: try {
-        guard case .oneofBytes(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 75)
-      }()
-      case .oneofEnum?: try {
-        guard case .oneofEnum(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 76)
-      }()
-      case .oneofGroup?: try {
-        guard case .oneofGroup(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularGroupField(value: v, fieldNumber: 77)
-      }()
-      case .oneofMessage?: try {
-        guard case .oneofMessage(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 79)
-      }()
-      case nil: break
-      }
-      if !_storage._repeatedPackedInt32.isEmpty {
-        try visitor.visitPackedInt32Field(value: _storage._repeatedPackedInt32, fieldNumber: 81)
-      }
-      if !_storage._repeatedPackedInt64.isEmpty {
-        try visitor.visitPackedInt64Field(value: _storage._repeatedPackedInt64, fieldNumber: 82)
-      }
-      if !_storage._repeatedPackedUint32.isEmpty {
-        try visitor.visitPackedUInt32Field(value: _storage._repeatedPackedUint32, fieldNumber: 83)
-      }
-      if !_storage._repeatedPackedUint64.isEmpty {
-        try visitor.visitPackedUInt64Field(value: _storage._repeatedPackedUint64, fieldNumber: 84)
-      }
-      if !_storage._repeatedPackedSint32.isEmpty {
-        try visitor.visitPackedSInt32Field(value: _storage._repeatedPackedSint32, fieldNumber: 85)
-      }
-      if !_storage._repeatedPackedSint64.isEmpty {
-        try visitor.visitPackedSInt64Field(value: _storage._repeatedPackedSint64, fieldNumber: 86)
-      }
-      if !_storage._repeatedPackedFixed32.isEmpty {
-        try visitor.visitPackedFixed32Field(value: _storage._repeatedPackedFixed32, fieldNumber: 87)
-      }
-      if !_storage._repeatedPackedFixed64.isEmpty {
-        try visitor.visitPackedFixed64Field(value: _storage._repeatedPackedFixed64, fieldNumber: 88)
-      }
-      if !_storage._repeatedPackedSfixed32.isEmpty {
-        try visitor.visitPackedSFixed32Field(value: _storage._repeatedPackedSfixed32, fieldNumber: 89)
-      }
-      if !_storage._repeatedPackedSfixed64.isEmpty {
-        try visitor.visitPackedSFixed64Field(value: _storage._repeatedPackedSfixed64, fieldNumber: 90)
-      }
-      if !_storage._repeatedPackedFloat.isEmpty {
-        try visitor.visitPackedFloatField(value: _storage._repeatedPackedFloat, fieldNumber: 91)
-      }
-      if !_storage._repeatedPackedDouble.isEmpty {
-        try visitor.visitPackedDoubleField(value: _storage._repeatedPackedDouble, fieldNumber: 92)
-      }
-      if !_storage._repeatedPackedBool.isEmpty {
-        try visitor.visitPackedBoolField(value: _storage._repeatedPackedBool, fieldNumber: 93)
-      }
-      if !_storage._repeatedPackedEnum.isEmpty {
-        try visitor.visitPackedEnumField(value: _storage._repeatedPackedEnum, fieldNumber: 94)
-      }
-      if !_storage._mapInt32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapInt32Int32, fieldNumber: 100)
-      }
-      if !_storage._mapInt32Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapInt32Int64, fieldNumber: 101)
-      }
-      if !_storage._mapInt32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapInt32Uint32, fieldNumber: 102)
-      }
-      if !_storage._mapInt32Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapInt32Uint64, fieldNumber: 103)
-      }
-      if !_storage._mapInt32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapInt32Sint32, fieldNumber: 104)
-      }
-      if !_storage._mapInt32Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapInt32Sint64, fieldNumber: 105)
-      }
-      if !_storage._mapInt32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapInt32Fixed32, fieldNumber: 106)
-      }
-      if !_storage._mapInt32Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapInt32Fixed64, fieldNumber: 107)
-      }
-      if !_storage._mapInt32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapInt32Sfixed32, fieldNumber: 108)
-      }
-      if !_storage._mapInt32Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapInt32Sfixed64, fieldNumber: 109)
-      }
-      if !_storage._mapInt32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapInt32Float, fieldNumber: 110)
-      }
-      if !_storage._mapInt32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapInt32Double, fieldNumber: 111)
-      }
-      if !_storage._mapInt32Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapInt32Bool, fieldNumber: 112)
-      }
-      if !_storage._mapInt32String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufString>.self, value: _storage._mapInt32String, fieldNumber: 113)
-      }
-      if !_storage._mapInt32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapInt32Bytes, fieldNumber: 114)
-      }
-      if !_storage._mapInt32AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapInt32AnEnum, fieldNumber: 115)
-      }
-      if !_storage._mapInt32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapInt32Message, fieldNumber: 116)
-      }
-      if !_storage._mapInt64Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapInt64Int32, fieldNumber: 117)
-      }
-      if !_storage._mapInt64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapInt64Int64, fieldNumber: 118)
-      }
-      if !_storage._mapInt64Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapInt64Uint32, fieldNumber: 119)
-      }
-      if !_storage._mapInt64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapInt64Uint64, fieldNumber: 120)
-      }
-      if !_storage._mapInt64Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapInt64Sint32, fieldNumber: 121)
-      }
-      if !_storage._mapInt64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapInt64Sint64, fieldNumber: 122)
-      }
-      if !_storage._mapInt64Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapInt64Fixed32, fieldNumber: 123)
-      }
-      if !_storage._mapInt64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapInt64Fixed64, fieldNumber: 124)
-      }
-      if !_storage._mapInt64Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapInt64Sfixed32, fieldNumber: 125)
-      }
-      if !_storage._mapInt64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapInt64Sfixed64, fieldNumber: 126)
-      }
-      if !_storage._mapInt64Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapInt64Float, fieldNumber: 127)
-      }
-      if !_storage._mapInt64Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapInt64Double, fieldNumber: 128)
-      }
-      if !_storage._mapInt64Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapInt64Bool, fieldNumber: 129)
-      }
-      if !_storage._mapInt64String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufString>.self, value: _storage._mapInt64String, fieldNumber: 130)
-      }
-      if !_storage._mapInt64Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapInt64Bytes, fieldNumber: 131)
-      }
-      if !_storage._mapInt64AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapInt64AnEnum, fieldNumber: 132)
-      }
-      if !_storage._mapInt64Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapInt64Message, fieldNumber: 133)
-      }
-      if !_storage._mapUint32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapUint32Int32, fieldNumber: 134)
-      }
-      if !_storage._mapUint32Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapUint32Int64, fieldNumber: 135)
-      }
-      if !_storage._mapUint32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapUint32Uint32, fieldNumber: 136)
-      }
-      if !_storage._mapUint32Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapUint32Uint64, fieldNumber: 137)
-      }
-      if !_storage._mapUint32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapUint32Sint32, fieldNumber: 138)
-      }
-      if !_storage._mapUint32Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapUint32Sint64, fieldNumber: 139)
-      }
-      if !_storage._mapUint32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapUint32Fixed32, fieldNumber: 140)
-      }
-      if !_storage._mapUint32Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapUint32Fixed64, fieldNumber: 141)
-      }
-      if !_storage._mapUint32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapUint32Sfixed32, fieldNumber: 142)
-      }
-      if !_storage._mapUint32Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapUint32Sfixed64, fieldNumber: 143)
-      }
-      if !_storage._mapUint32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapUint32Float, fieldNumber: 144)
-      }
-      if !_storage._mapUint32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapUint32Double, fieldNumber: 145)
-      }
-      if !_storage._mapUint32Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapUint32Bool, fieldNumber: 146)
-      }
-      if !_storage._mapUint32String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufString>.self, value: _storage._mapUint32String, fieldNumber: 147)
-      }
-      if !_storage._mapUint32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapUint32Bytes, fieldNumber: 148)
-      }
-      if !_storage._mapUint32AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapUint32AnEnum, fieldNumber: 149)
-      }
-      if !_storage._mapUint32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapUint32Message, fieldNumber: 150)
-      }
-      if !_storage._mapUint64Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapUint64Int32, fieldNumber: 151)
-      }
-      if !_storage._mapUint64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapUint64Int64, fieldNumber: 152)
-      }
-      if !_storage._mapUint64Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapUint64Uint32, fieldNumber: 153)
-      }
-      if !_storage._mapUint64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapUint64Uint64, fieldNumber: 154)
-      }
-      if !_storage._mapUint64Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapUint64Sint32, fieldNumber: 155)
-      }
-      if !_storage._mapUint64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapUint64Sint64, fieldNumber: 156)
-      }
-      if !_storage._mapUint64Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapUint64Fixed32, fieldNumber: 157)
-      }
-      if !_storage._mapUint64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapUint64Fixed64, fieldNumber: 158)
-      }
-      if !_storage._mapUint64Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapUint64Sfixed32, fieldNumber: 159)
-      }
-      if !_storage._mapUint64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapUint64Sfixed64, fieldNumber: 160)
-      }
-      if !_storage._mapUint64Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapUint64Float, fieldNumber: 161)
-      }
-      if !_storage._mapUint64Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapUint64Double, fieldNumber: 162)
-      }
-      if !_storage._mapUint64Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapUint64Bool, fieldNumber: 163)
-      }
-      if !_storage._mapUint64String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufString>.self, value: _storage._mapUint64String, fieldNumber: 164)
-      }
-      if !_storage._mapUint64Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapUint64Bytes, fieldNumber: 165)
-      }
-      if !_storage._mapUint64AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapUint64AnEnum, fieldNumber: 166)
-      }
-      if !_storage._mapUint64Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapUint64Message, fieldNumber: 167)
-      }
-      if !_storage._mapSint32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapSint32Int32, fieldNumber: 168)
-      }
-      if !_storage._mapSint32Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapSint32Int64, fieldNumber: 169)
-      }
-      if !_storage._mapSint32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapSint32Uint32, fieldNumber: 170)
-      }
-      if !_storage._mapSint32Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapSint32Uint64, fieldNumber: 171)
-      }
-      if !_storage._mapSint32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSint32Sint32, fieldNumber: 172)
-      }
-      if !_storage._mapSint32Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSint32Sint64, fieldNumber: 173)
-      }
-      if !_storage._mapSint32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapSint32Fixed32, fieldNumber: 174)
-      }
-      if !_storage._mapSint32Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapSint32Fixed64, fieldNumber: 175)
-      }
-      if !_storage._mapSint32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSint32Sfixed32, fieldNumber: 176)
-      }
-      if !_storage._mapSint32Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSint32Sfixed64, fieldNumber: 177)
-      }
-      if !_storage._mapSint32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapSint32Float, fieldNumber: 178)
-      }
-      if !_storage._mapSint32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapSint32Double, fieldNumber: 179)
-      }
-      if !_storage._mapSint32Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapSint32Bool, fieldNumber: 180)
-      }
-      if !_storage._mapSint32String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufString>.self, value: _storage._mapSint32String, fieldNumber: 181)
-      }
-      if !_storage._mapSint32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapSint32Bytes, fieldNumber: 182)
-      }
-      if !_storage._mapSint32AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapSint32AnEnum, fieldNumber: 183)
-      }
-      if !_storage._mapSint32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapSint32Message, fieldNumber: 184)
-      }
-      if !_storage._mapSint64Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapSint64Int32, fieldNumber: 185)
-      }
-      if !_storage._mapSint64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapSint64Int64, fieldNumber: 186)
-      }
-      if !_storage._mapSint64Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapSint64Uint32, fieldNumber: 187)
-      }
-      if !_storage._mapSint64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapSint64Uint64, fieldNumber: 188)
-      }
-      if !_storage._mapSint64Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSint64Sint32, fieldNumber: 189)
-      }
-      if !_storage._mapSint64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSint64Sint64, fieldNumber: 190)
-      }
-      if !_storage._mapSint64Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapSint64Fixed32, fieldNumber: 191)
-      }
-      if !_storage._mapSint64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapSint64Fixed64, fieldNumber: 192)
-      }
-      if !_storage._mapSint64Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSint64Sfixed32, fieldNumber: 193)
-      }
-      if !_storage._mapSint64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSint64Sfixed64, fieldNumber: 194)
-      }
-      if !_storage._mapSint64Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapSint64Float, fieldNumber: 195)
-      }
-      if !_storage._mapSint64Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapSint64Double, fieldNumber: 196)
-      }
-      if !_storage._mapSint64Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapSint64Bool, fieldNumber: 197)
-      }
-      if !_storage._mapSint64String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufString>.self, value: _storage._mapSint64String, fieldNumber: 198)
-      }
-      if !_storage._mapSint64Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapSint64Bytes, fieldNumber: 199)
-      }
-      if !_storage._mapSint64AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapSint64AnEnum, fieldNumber: 200)
-      }
-      if !_storage._mapSint64Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapSint64Message, fieldNumber: 201)
-      }
-      if !_storage._mapFixed32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapFixed32Int32, fieldNumber: 202)
-      }
-      if !_storage._mapFixed32Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapFixed32Int64, fieldNumber: 203)
-      }
-      if !_storage._mapFixed32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapFixed32Uint32, fieldNumber: 204)
-      }
-      if !_storage._mapFixed32Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapFixed32Uint64, fieldNumber: 205)
-      }
-      if !_storage._mapFixed32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapFixed32Sint32, fieldNumber: 206)
-      }
-      if !_storage._mapFixed32Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapFixed32Sint64, fieldNumber: 207)
-      }
-      if !_storage._mapFixed32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapFixed32Fixed32, fieldNumber: 208)
-      }
-      if !_storage._mapFixed32Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapFixed32Fixed64, fieldNumber: 209)
-      }
-      if !_storage._mapFixed32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapFixed32Sfixed32, fieldNumber: 210)
-      }
-      if !_storage._mapFixed32Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapFixed32Sfixed64, fieldNumber: 211)
-      }
-      if !_storage._mapFixed32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapFixed32Float, fieldNumber: 212)
-      }
-      if !_storage._mapFixed32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapFixed32Double, fieldNumber: 213)
-      }
-      if !_storage._mapFixed32Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapFixed32Bool, fieldNumber: 214)
-      }
-      if !_storage._mapFixed32String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufString>.self, value: _storage._mapFixed32String, fieldNumber: 215)
-      }
-      if !_storage._mapFixed32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapFixed32Bytes, fieldNumber: 216)
-      }
-      if !_storage._mapFixed32AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapFixed32AnEnum, fieldNumber: 217)
-      }
-      if !_storage._mapFixed32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapFixed32Message, fieldNumber: 218)
-      }
-      if !_storage._mapFixed64Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapFixed64Int32, fieldNumber: 219)
-      }
-      if !_storage._mapFixed64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapFixed64Int64, fieldNumber: 220)
-      }
-      if !_storage._mapFixed64Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapFixed64Uint32, fieldNumber: 221)
-      }
-      if !_storage._mapFixed64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapFixed64Uint64, fieldNumber: 222)
-      }
-      if !_storage._mapFixed64Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapFixed64Sint32, fieldNumber: 223)
-      }
-      if !_storage._mapFixed64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapFixed64Sint64, fieldNumber: 224)
-      }
-      if !_storage._mapFixed64Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapFixed64Fixed32, fieldNumber: 225)
-      }
-      if !_storage._mapFixed64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapFixed64Fixed64, fieldNumber: 226)
-      }
-      if !_storage._mapFixed64Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapFixed64Sfixed32, fieldNumber: 227)
-      }
-      if !_storage._mapFixed64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapFixed64Sfixed64, fieldNumber: 228)
-      }
-      if !_storage._mapFixed64Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapFixed64Float, fieldNumber: 229)
-      }
-      if !_storage._mapFixed64Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapFixed64Double, fieldNumber: 230)
-      }
-      if !_storage._mapFixed64Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapFixed64Bool, fieldNumber: 231)
-      }
-      if !_storage._mapFixed64String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufString>.self, value: _storage._mapFixed64String, fieldNumber: 232)
-      }
-      if !_storage._mapFixed64Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapFixed64Bytes, fieldNumber: 233)
-      }
-      if !_storage._mapFixed64AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapFixed64AnEnum, fieldNumber: 234)
-      }
-      if !_storage._mapFixed64Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapFixed64Message, fieldNumber: 235)
-      }
-      if !_storage._mapSfixed32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapSfixed32Int32, fieldNumber: 236)
-      }
-      if !_storage._mapSfixed32Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapSfixed32Int64, fieldNumber: 237)
-      }
-      if !_storage._mapSfixed32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapSfixed32Uint32, fieldNumber: 238)
-      }
-      if !_storage._mapSfixed32Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapSfixed32Uint64, fieldNumber: 239)
-      }
-      if !_storage._mapSfixed32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSfixed32Sint32, fieldNumber: 240)
-      }
-      if !_storage._mapSfixed32Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSfixed32Sint64, fieldNumber: 241)
-      }
-      if !_storage._mapSfixed32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapSfixed32Fixed32, fieldNumber: 242)
-      }
-      if !_storage._mapSfixed32Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapSfixed32Fixed64, fieldNumber: 243)
-      }
-      if !_storage._mapSfixed32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 244)
-      }
-      if !_storage._mapSfixed32Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSfixed32Sfixed64, fieldNumber: 245)
-      }
-      if !_storage._mapSfixed32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapSfixed32Float, fieldNumber: 246)
-      }
-      if !_storage._mapSfixed32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapSfixed32Double, fieldNumber: 247)
-      }
-      if !_storage._mapSfixed32Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapSfixed32Bool, fieldNumber: 248)
-      }
-      if !_storage._mapSfixed32String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufString>.self, value: _storage._mapSfixed32String, fieldNumber: 249)
-      }
-      if !_storage._mapSfixed32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapSfixed32Bytes, fieldNumber: 250)
-      }
-      if !_storage._mapSfixed32AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapSfixed32AnEnum, fieldNumber: 251)
-      }
-      if !_storage._mapSfixed32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapSfixed32Message, fieldNumber: 252)
-      }
-      if !_storage._mapSfixed64Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapSfixed64Int32, fieldNumber: 253)
-      }
-      if !_storage._mapSfixed64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapSfixed64Int64, fieldNumber: 254)
-      }
-      if !_storage._mapSfixed64Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapSfixed64Uint32, fieldNumber: 255)
-      }
-      if !_storage._mapSfixed64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapSfixed64Uint64, fieldNumber: 256)
-      }
-      if !_storage._mapSfixed64Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSfixed64Sint32, fieldNumber: 257)
-      }
-      if !_storage._mapSfixed64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSfixed64Sint64, fieldNumber: 258)
-      }
-      if !_storage._mapSfixed64Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapSfixed64Fixed32, fieldNumber: 259)
-      }
-      if !_storage._mapSfixed64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapSfixed64Fixed64, fieldNumber: 260)
-      }
-      if !_storage._mapSfixed64Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSfixed64Sfixed32, fieldNumber: 261)
-      }
-      if !_storage._mapSfixed64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 262)
-      }
-      if !_storage._mapSfixed64Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapSfixed64Float, fieldNumber: 263)
-      }
-      if !_storage._mapSfixed64Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapSfixed64Double, fieldNumber: 264)
-      }
-      if !_storage._mapSfixed64Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapSfixed64Bool, fieldNumber: 265)
-      }
-      if !_storage._mapSfixed64String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufString>.self, value: _storage._mapSfixed64String, fieldNumber: 266)
-      }
-      if !_storage._mapSfixed64Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapSfixed64Bytes, fieldNumber: 267)
-      }
-      if !_storage._mapSfixed64AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapSfixed64AnEnum, fieldNumber: 268)
-      }
-      if !_storage._mapSfixed64Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapSfixed64Message, fieldNumber: 269)
-      }
-      if !_storage._mapBoolInt32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapBoolInt32, fieldNumber: 270)
-      }
-      if !_storage._mapBoolInt64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapBoolInt64, fieldNumber: 271)
-      }
-      if !_storage._mapBoolUint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapBoolUint32, fieldNumber: 272)
-      }
-      if !_storage._mapBoolUint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapBoolUint64, fieldNumber: 273)
-      }
-      if !_storage._mapBoolSint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapBoolSint32, fieldNumber: 274)
-      }
-      if !_storage._mapBoolSint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapBoolSint64, fieldNumber: 275)
-      }
-      if !_storage._mapBoolFixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapBoolFixed32, fieldNumber: 276)
-      }
-      if !_storage._mapBoolFixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapBoolFixed64, fieldNumber: 277)
-      }
-      if !_storage._mapBoolSfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapBoolSfixed32, fieldNumber: 278)
-      }
-      if !_storage._mapBoolSfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapBoolSfixed64, fieldNumber: 279)
-      }
-      if !_storage._mapBoolFloat.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapBoolFloat, fieldNumber: 280)
-      }
-      if !_storage._mapBoolDouble.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapBoolDouble, fieldNumber: 281)
-      }
-      if !_storage._mapBoolBool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapBoolBool, fieldNumber: 282)
-      }
-      if !_storage._mapBoolString.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufString>.self, value: _storage._mapBoolString, fieldNumber: 283)
-      }
-      if !_storage._mapBoolBytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapBoolBytes, fieldNumber: 284)
-      }
-      if !_storage._mapBoolAnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapBoolAnEnum, fieldNumber: 285)
-      }
-      if !_storage._mapBoolMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapBoolMessage, fieldNumber: 286)
-      }
-      try { if let v = _storage._wktAny {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 500)
-      } }()
-      try { if let v = _storage._wktApi {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 501)
-      } }()
-      try { if let v = _storage._wktDuration {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 502)
-      } }()
-      try { if let v = _storage._wktEmpty {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 503)
-      } }()
-      try { if let v = _storage._wktFieldMask {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 504)
-      } }()
-      try { if let v = _storage._wktSourceContext {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 505)
-      } }()
-      try { if let v = _storage._wktStruct {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 506)
-      } }()
-      try { if let v = _storage._wktTimestamp {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 507)
-      } }()
-      try { if let v = _storage._wktType {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 508)
-      } }()
-      try { if let v = _storage._wktDoubleValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 509)
-      } }()
-      try { if let v = _storage._wktFloatValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 510)
-      } }()
-      try { if let v = _storage._wktInt64Value {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 511)
-      } }()
-      try { if let v = _storage._wktUint64Value {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 512)
-      } }()
-      try { if let v = _storage._wktInt32Value {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 513)
-      } }()
-      try { if let v = _storage._wktUint32Value {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 514)
-      } }()
-      try { if let v = _storage._wktBoolValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 515)
-      } }()
-      try { if let v = _storage._wktStringValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 516)
-      } }()
-      try { if let v = _storage._wktBytesValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 517)
-      } }()
-      try { if let v = _storage._singularMessageSet {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 600)
-      } }()
-      if !_storage._repeatedMessageSet.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedMessageSet, fieldNumber: 601)
-      }
-      try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 2001)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularInt32 }, fieldNumber: 1, isUnset: { $0._storage._singularInt32 == nil }),
+    .singularInt64({ $0.singularInt64 }, fieldNumber: 2, isUnset: { $0._storage._singularInt64 == nil }),
+    .singularUInt32({ $0.singularUint32 }, fieldNumber: 3, isUnset: { $0._storage._singularUint32 == nil }),
+    .singularUInt64({ $0.singularUint64 }, fieldNumber: 4, isUnset: { $0._storage._singularUint64 == nil }),
+    .singularSInt32({ $0.singularSint32 }, fieldNumber: 5, isUnset: { $0._storage._singularSint32 == nil }),
+    .singularSInt64({ $0.singularSint64 }, fieldNumber: 6, isUnset: { $0._storage._singularSint64 == nil }),
+    .singularFixed32({ $0.singularFixed32 }, fieldNumber: 7, isUnset: { $0._storage._singularFixed32 == nil }),
+    .singularFixed64({ $0.singularFixed64 }, fieldNumber: 8, isUnset: { $0._storage._singularFixed64 == nil }),
+    .singularSFixed32({ $0.singularSfixed32 }, fieldNumber: 9, isUnset: { $0._storage._singularSfixed32 == nil }),
+    .singularSFixed64({ $0.singularSfixed64 }, fieldNumber: 10, isUnset: { $0._storage._singularSfixed64 == nil }),
+    .singularFloat({ $0.singularFloat }, fieldNumber: 11, isUnset: { $0._storage._singularFloat == nil }),
+    .singularDouble({ $0.singularDouble }, fieldNumber: 12, isUnset: { $0._storage._singularDouble == nil }),
+    .singularBool({ $0.singularBool }, fieldNumber: 13, isUnset: { $0._storage._singularBool == nil }),
+    .singularString({ $0.singularString }, fieldNumber: 14, isUnset: { $0._storage._singularString == nil }),
+    .singularBytes({ $0.singularBytes }, fieldNumber: 15, isUnset: { $0._storage._singularBytes == nil }),
+    .singularEnum({ $0.singularEnum }, fieldNumber: 16, isUnset: { $0._storage._singularEnum == nil }),
+    .singularGroup({ $0.singularGroup }, fieldNumber: 17, isUnset: { $0._storage._singularGroup == nil }),
+    .singularMessage({ $0.singularMessage }, fieldNumber: 19, isUnset: { $0._storage._singularMessage == nil }),
+    .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
+    .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
+    .repeatedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
+    .repeatedUInt64({ $0.repeatedUint64 }, fieldNumber: 34),
+    .repeatedSInt32({ $0.repeatedSint32 }, fieldNumber: 35),
+    .repeatedSInt64({ $0.repeatedSint64 }, fieldNumber: 36),
+    .repeatedFixed32({ $0.repeatedFixed32 }, fieldNumber: 37),
+    .repeatedFixed64({ $0.repeatedFixed64 }, fieldNumber: 38),
+    .repeatedSFixed32({ $0.repeatedSfixed32 }, fieldNumber: 39),
+    .repeatedSFixed64({ $0.repeatedSfixed64 }, fieldNumber: 40),
+    .repeatedFloat({ $0.repeatedFloat }, fieldNumber: 41),
+    .repeatedDouble({ $0.repeatedDouble }, fieldNumber: 42),
+    .repeatedBool({ $0.repeatedBool }, fieldNumber: 43),
+    .repeatedString({ $0.repeatedString }, fieldNumber: 44),
+    .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
+    .repeatedEnum({ $0.repeatedEnum }, fieldNumber: 46),
+    .repeatedGroup({ $0.repeatedGroup }, fieldNumber: 47),
+    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 49),
+    .oneOf({ $0.o }) {
+      switch $0 {
+      case .oneofInt32:
+        return _oneOfField_oneofInt32
+      case .oneofInt64:
+        return _oneOfField_oneofInt64
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofUint64:
+        return _oneOfField_oneofUint64
+      case .oneofSint32:
+        return _oneOfField_oneofSint32
+      case .oneofSint64:
+        return _oneOfField_oneofSint64
+      case .oneofFixed32:
+        return _oneOfField_oneofFixed32
+      case .oneofFixed64:
+        return _oneOfField_oneofFixed64
+      case .oneofSfixed32:
+        return _oneOfField_oneofSfixed32
+      case .oneofSfixed64:
+        return _oneOfField_oneofSfixed64
+      case .oneofFloat:
+        return _oneOfField_oneofFloat
+      case .oneofDouble:
+        return _oneOfField_oneofDouble
+      case .oneofBool:
+        return _oneOfField_oneofBool
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
+      case .oneofEnum:
+        return _oneOfField_oneofEnum
+      case .oneofGroup:
+        return _oneOfField_oneofGroup
+      case .oneofMessage:
+        return _oneOfField_oneofMessage
+      }
+    },
+    .packedInt32({ $0.repeatedPackedInt32 }, fieldNumber: 81),
+    .packedInt64({ $0.repeatedPackedInt64 }, fieldNumber: 82),
+    .packedUInt32({ $0.repeatedPackedUint32 }, fieldNumber: 83),
+    .packedUInt64({ $0.repeatedPackedUint64 }, fieldNumber: 84),
+    .packedSInt32({ $0.repeatedPackedSint32 }, fieldNumber: 85),
+    .packedSInt64({ $0.repeatedPackedSint64 }, fieldNumber: 86),
+    .packedFixed32({ $0.repeatedPackedFixed32 }, fieldNumber: 87),
+    .packedFixed64({ $0.repeatedPackedFixed64 }, fieldNumber: 88),
+    .packedSFixed32({ $0.repeatedPackedSfixed32 }, fieldNumber: 89),
+    .packedSFixed64({ $0.repeatedPackedSfixed64 }, fieldNumber: 90),
+    .packedFloat({ $0.repeatedPackedFloat }, fieldNumber: 91),
+    .packedDouble({ $0.repeatedPackedDouble }, fieldNumber: 92),
+    .packedBool({ $0.repeatedPackedBool }, fieldNumber: 93),
+    .packedEnum({ $0.repeatedPackedEnum }, fieldNumber: 94),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 100),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt32Int64 }, fieldNumber: 101),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapInt32Uint32 }, fieldNumber: 102),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapInt32Uint64 }, fieldNumber: 103),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapInt32Sint32 }, fieldNumber: 104),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapInt32Sint64 }, fieldNumber: 105),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapInt32Fixed32 }, fieldNumber: 106),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapInt32Fixed64 }, fieldNumber: 107),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapInt32Sfixed32 }, fieldNumber: 108),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapInt32Sfixed64 }, fieldNumber: 109),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 110),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 111),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapInt32Bool }, fieldNumber: 112),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapInt32String }, fieldNumber: 113),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt32Bytes }, fieldNumber: 114),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapInt32AnEnum }, fieldNumber: 115),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapInt32Message }, fieldNumber: 116),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt64Int32 }, fieldNumber: 117),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 118),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapInt64Uint32 }, fieldNumber: 119),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapInt64Uint64 }, fieldNumber: 120),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapInt64Sint32 }, fieldNumber: 121),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapInt64Sint64 }, fieldNumber: 122),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapInt64Fixed32 }, fieldNumber: 123),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapInt64Fixed64 }, fieldNumber: 124),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapInt64Sfixed32 }, fieldNumber: 125),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapInt64Sfixed64 }, fieldNumber: 126),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt64Float }, fieldNumber: 127),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt64Double }, fieldNumber: 128),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapInt64Bool }, fieldNumber: 129),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapInt64String }, fieldNumber: 130),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt64Bytes }, fieldNumber: 131),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapInt64AnEnum }, fieldNumber: 132),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapInt64Message }, fieldNumber: 133),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapUint32Int32 }, fieldNumber: 134),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapUint32Int64 }, fieldNumber: 135),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 136),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint32Uint64 }, fieldNumber: 137),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapUint32Sint32 }, fieldNumber: 138),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapUint32Sint64 }, fieldNumber: 139),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapUint32Fixed32 }, fieldNumber: 140),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapUint32Fixed64 }, fieldNumber: 141),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapUint32Sfixed32 }, fieldNumber: 142),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapUint32Sfixed64 }, fieldNumber: 143),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapUint32Float }, fieldNumber: 144),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapUint32Double }, fieldNumber: 145),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapUint32Bool }, fieldNumber: 146),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapUint32String }, fieldNumber: 147),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapUint32Bytes }, fieldNumber: 148),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapUint32AnEnum }, fieldNumber: 149),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapUint32Message }, fieldNumber: 150),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapUint64Int32 }, fieldNumber: 151),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapUint64Int64 }, fieldNumber: 152),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint64Uint32 }, fieldNumber: 153),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 154),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapUint64Sint32 }, fieldNumber: 155),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapUint64Sint64 }, fieldNumber: 156),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapUint64Fixed32 }, fieldNumber: 157),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapUint64Fixed64 }, fieldNumber: 158),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapUint64Sfixed32 }, fieldNumber: 159),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapUint64Sfixed64 }, fieldNumber: 160),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapUint64Float }, fieldNumber: 161),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapUint64Double }, fieldNumber: 162),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapUint64Bool }, fieldNumber: 163),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapUint64String }, fieldNumber: 164),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapUint64Bytes }, fieldNumber: 165),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapUint64AnEnum }, fieldNumber: 166),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapUint64Message }, fieldNumber: 167),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSint32Int32 }, fieldNumber: 168),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSint32Int64 }, fieldNumber: 169),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSint32Uint32 }, fieldNumber: 170),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSint32Uint64 }, fieldNumber: 171),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 172),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint32Sint64 }, fieldNumber: 173),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSint32Fixed32 }, fieldNumber: 174),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSint32Fixed64 }, fieldNumber: 175),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSint32Sfixed32 }, fieldNumber: 176),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSint32Sfixed64 }, fieldNumber: 177),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSint32Float }, fieldNumber: 178),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSint32Double }, fieldNumber: 179),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapSint32Bool }, fieldNumber: 180),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapSint32String }, fieldNumber: 181),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSint32Bytes }, fieldNumber: 182),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSint32AnEnum }, fieldNumber: 183),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSint32Message }, fieldNumber: 184),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSint64Int32 }, fieldNumber: 185),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSint64Int64 }, fieldNumber: 186),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSint64Uint32 }, fieldNumber: 187),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSint64Uint64 }, fieldNumber: 188),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint64Sint32 }, fieldNumber: 189),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 190),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSint64Fixed32 }, fieldNumber: 191),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSint64Fixed64 }, fieldNumber: 192),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSint64Sfixed32 }, fieldNumber: 193),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSint64Sfixed64 }, fieldNumber: 194),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSint64Float }, fieldNumber: 195),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSint64Double }, fieldNumber: 196),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapSint64Bool }, fieldNumber: 197),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapSint64String }, fieldNumber: 198),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSint64Bytes }, fieldNumber: 199),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSint64AnEnum }, fieldNumber: 200),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSint64Message }, fieldNumber: 201),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapFixed32Int32 }, fieldNumber: 202),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapFixed32Int64 }, fieldNumber: 203),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapFixed32Uint32 }, fieldNumber: 204),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapFixed32Uint64 }, fieldNumber: 205),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapFixed32Sint32 }, fieldNumber: 206),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapFixed32Sint64 }, fieldNumber: 207),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 208),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed32Fixed64 }, fieldNumber: 209),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapFixed32Sfixed32 }, fieldNumber: 210),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapFixed32Sfixed64 }, fieldNumber: 211),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapFixed32Float }, fieldNumber: 212),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapFixed32Double }, fieldNumber: 213),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBool>.self, { $0.mapFixed32Bool }, fieldNumber: 214),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufString>.self, { $0.mapFixed32String }, fieldNumber: 215),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapFixed32Bytes }, fieldNumber: 216),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapFixed32AnEnum }, fieldNumber: 217),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapFixed32Message }, fieldNumber: 218),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapFixed64Int32 }, fieldNumber: 219),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapFixed64Int64 }, fieldNumber: 220),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapFixed64Uint32 }, fieldNumber: 221),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapFixed64Uint64 }, fieldNumber: 222),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapFixed64Sint32 }, fieldNumber: 223),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapFixed64Sint64 }, fieldNumber: 224),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed64Fixed32 }, fieldNumber: 225),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 226),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapFixed64Sfixed32 }, fieldNumber: 227),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapFixed64Sfixed64 }, fieldNumber: 228),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapFixed64Float }, fieldNumber: 229),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapFixed64Double }, fieldNumber: 230),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBool>.self, { $0.mapFixed64Bool }, fieldNumber: 231),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufString>.self, { $0.mapFixed64String }, fieldNumber: 232),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapFixed64Bytes }, fieldNumber: 233),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapFixed64AnEnum }, fieldNumber: 234),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapFixed64Message }, fieldNumber: 235),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSfixed32Int32 }, fieldNumber: 236),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSfixed32Int64 }, fieldNumber: 237),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSfixed32Uint32 }, fieldNumber: 238),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSfixed32Uint64 }, fieldNumber: 239),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSfixed32Sint32 }, fieldNumber: 240),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSfixed32Sint64 }, fieldNumber: 241),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSfixed32Fixed32 }, fieldNumber: 242),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSfixed32Fixed64 }, fieldNumber: 243),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 244),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed32Sfixed64 }, fieldNumber: 245),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSfixed32Float }, fieldNumber: 246),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSfixed32Double }, fieldNumber: 247),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBool>.self, { $0.mapSfixed32Bool }, fieldNumber: 248),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufString>.self, { $0.mapSfixed32String }, fieldNumber: 249),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSfixed32Bytes }, fieldNumber: 250),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSfixed32AnEnum }, fieldNumber: 251),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSfixed32Message }, fieldNumber: 252),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSfixed64Int32 }, fieldNumber: 253),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSfixed64Int64 }, fieldNumber: 254),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSfixed64Uint32 }, fieldNumber: 255),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSfixed64Uint64 }, fieldNumber: 256),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSfixed64Sint32 }, fieldNumber: 257),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSfixed64Sint64 }, fieldNumber: 258),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSfixed64Fixed32 }, fieldNumber: 259),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSfixed64Fixed64 }, fieldNumber: 260),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed64Sfixed32 }, fieldNumber: 261),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 262),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSfixed64Float }, fieldNumber: 263),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSfixed64Double }, fieldNumber: 264),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBool>.self, { $0.mapSfixed64Bool }, fieldNumber: 265),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufString>.self, { $0.mapSfixed64String }, fieldNumber: 266),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSfixed64Bytes }, fieldNumber: 267),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSfixed64AnEnum }, fieldNumber: 268),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSfixed64Message }, fieldNumber: 269),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt32>.self, { $0.mapBoolInt32 }, fieldNumber: 270),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt64>.self, { $0.mapBoolInt64 }, fieldNumber: 271),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapBoolUint32 }, fieldNumber: 272),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapBoolUint64 }, fieldNumber: 273),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapBoolSint32 }, fieldNumber: 274),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapBoolSint64 }, fieldNumber: 275),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapBoolFixed32 }, fieldNumber: 276),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapBoolFixed64 }, fieldNumber: 277),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapBoolSfixed32 }, fieldNumber: 278),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapBoolSfixed64 }, fieldNumber: 279),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFloat>.self, { $0.mapBoolFloat }, fieldNumber: 280),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufDouble>.self, { $0.mapBoolDouble }, fieldNumber: 281),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 282),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufString>.self, { $0.mapBoolString }, fieldNumber: 283),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBytes>.self, { $0.mapBoolBytes }, fieldNumber: 284),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapBoolAnEnum }, fieldNumber: 285),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapBoolMessage }, fieldNumber: 286),
+    .singularMessage({ $0.wktAny }, fieldNumber: 500, isUnset: { $0._storage._wktAny == nil }),
+    .singularMessage({ $0.wktApi }, fieldNumber: 501, isUnset: { $0._storage._wktApi == nil }),
+    .singularMessage({ $0.wktDuration }, fieldNumber: 502, isUnset: { $0._storage._wktDuration == nil }),
+    .singularMessage({ $0.wktEmpty }, fieldNumber: 503, isUnset: { $0._storage._wktEmpty == nil }),
+    .singularMessage({ $0.wktFieldMask }, fieldNumber: 504, isUnset: { $0._storage._wktFieldMask == nil }),
+    .singularMessage({ $0.wktSourceContext }, fieldNumber: 505, isUnset: { $0._storage._wktSourceContext == nil }),
+    .singularMessage({ $0.wktStruct }, fieldNumber: 506, isUnset: { $0._storage._wktStruct == nil }),
+    .singularMessage({ $0.wktTimestamp }, fieldNumber: 507, isUnset: { $0._storage._wktTimestamp == nil }),
+    .singularMessage({ $0.wktType }, fieldNumber: 508, isUnset: { $0._storage._wktType == nil }),
+    .singularMessage({ $0.wktDoubleValue }, fieldNumber: 509, isUnset: { $0._storage._wktDoubleValue == nil }),
+    .singularMessage({ $0.wktFloatValue }, fieldNumber: 510, isUnset: { $0._storage._wktFloatValue == nil }),
+    .singularMessage({ $0.wktInt64Value }, fieldNumber: 511, isUnset: { $0._storage._wktInt64Value == nil }),
+    .singularMessage({ $0.wktUint64Value }, fieldNumber: 512, isUnset: { $0._storage._wktUint64Value == nil }),
+    .singularMessage({ $0.wktInt32Value }, fieldNumber: 513, isUnset: { $0._storage._wktInt32Value == nil }),
+    .singularMessage({ $0.wktUint32Value }, fieldNumber: 514, isUnset: { $0._storage._wktUint32Value == nil }),
+    .singularMessage({ $0.wktBoolValue }, fieldNumber: 515, isUnset: { $0._storage._wktBoolValue == nil }),
+    .singularMessage({ $0.wktStringValue }, fieldNumber: 516, isUnset: { $0._storage._wktStringValue == nil }),
+    .singularMessage({ $0.wktBytesValue }, fieldNumber: 517, isUnset: { $0._storage._wktBytesValue == nil }),
+    .singularMessage({ $0.singularMessageSet }, fieldNumber: 600, isUnset: { $0._storage._singularMessageSet == nil }),
+    .repeatedMessage({ $0.repeatedMessageSet }, fieldNumber: 601),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 2001),
+  ]
+  private static let _oneOfField_oneofInt32: Field<Self> = .singularInt32({ $0.oneofInt32 }, fieldNumber: 61, isUnset: { _ in false })
+  private static let _oneOfField_oneofInt64: Field<Self> = .singularInt64({ $0.oneofInt64 }, fieldNumber: 62, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 63, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint64: Field<Self> = .singularUInt64({ $0.oneofUint64 }, fieldNumber: 64, isUnset: { _ in false })
+  private static let _oneOfField_oneofSint32: Field<Self> = .singularSInt32({ $0.oneofSint32 }, fieldNumber: 65, isUnset: { _ in false })
+  private static let _oneOfField_oneofSint64: Field<Self> = .singularSInt64({ $0.oneofSint64 }, fieldNumber: 66, isUnset: { _ in false })
+  private static let _oneOfField_oneofFixed32: Field<Self> = .singularFixed32({ $0.oneofFixed32 }, fieldNumber: 67, isUnset: { _ in false })
+  private static let _oneOfField_oneofFixed64: Field<Self> = .singularFixed64({ $0.oneofFixed64 }, fieldNumber: 68, isUnset: { _ in false })
+  private static let _oneOfField_oneofSfixed32: Field<Self> = .singularSFixed32({ $0.oneofSfixed32 }, fieldNumber: 69, isUnset: { _ in false })
+  private static let _oneOfField_oneofSfixed64: Field<Self> = .singularSFixed64({ $0.oneofSfixed64 }, fieldNumber: 70, isUnset: { _ in false })
+  private static let _oneOfField_oneofFloat: Field<Self> = .singularFloat({ $0.oneofFloat }, fieldNumber: 71, isUnset: { _ in false })
+  private static let _oneOfField_oneofDouble: Field<Self> = .singularDouble({ $0.oneofDouble }, fieldNumber: 72, isUnset: { _ in false })
+  private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 73, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 74, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 75, isUnset: { _ in false })
+  private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 76, isUnset: { _ in false })
+  private static let _oneOfField_oneofGroup: Field<Self> = .singularGroup({ $0.oneofGroup }, fieldNumber: 77, isUnset: { _ in false })
+  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 79, isUnset: { _ in false })
+
 
   public static func ==(lhs: SwiftProtoTesting_Fuzz_Message, rhs: SwiftProtoTesting_Fuzz_Message) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -5000,16 +4463,10 @@ extension SwiftProtoTesting_Fuzz_Message.SingularGroup: SwiftProtobuf.Message, S
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 18)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupField }, fieldNumber: 18, isUnset: { $0._groupField == nil }),
+  ]
+
 
   public static func ==(lhs: SwiftProtoTesting_Fuzz_Message.SingularGroup, rhs: SwiftProtoTesting_Fuzz_Message.SingularGroup) -> Bool {
     if lhs._groupField != rhs._groupField {return false}
@@ -5036,16 +4493,10 @@ extension SwiftProtoTesting_Fuzz_Message.RepeatedGroup: SwiftProtobuf.Message, S
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 48)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupField }, fieldNumber: 48, isUnset: { $0._groupField == nil }),
+  ]
+
 
   public static func ==(lhs: SwiftProtoTesting_Fuzz_Message.RepeatedGroup, rhs: SwiftProtoTesting_Fuzz_Message.RepeatedGroup) -> Bool {
     if lhs._groupField != rhs._groupField {return false}
@@ -5072,16 +4523,10 @@ extension SwiftProtoTesting_Fuzz_Message.OneofGroup: SwiftProtobuf.Message, Swif
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 78)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupField }, fieldNumber: 78, isUnset: { $0._groupField == nil }),
+  ]
+
 
   public static func ==(lhs: SwiftProtoTesting_Fuzz_Message.OneofGroup, rhs: SwiftProtoTesting_Fuzz_Message.OneofGroup) -> Bool {
     if lhs._groupField != rhs._groupField {return false}
@@ -5103,10 +4548,10 @@ extension SwiftProtoTesting_Fuzz_AMessageSetMessage: SwiftProtobuf.Message, Swif
     try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Fuzz_AMessageSetMessage.self)
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .extensionFieldsAsMessageSet({ $0._protobuf_extensionFieldValues }, start: 4, end: 2147483647),
+  ]
+
 
   public static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessage, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -5133,16 +4578,10 @@ extension SwiftProtoTesting_Fuzz_SingularGroup_ext: SwiftProtobuf.Message, Swift
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1018)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupField }, fieldNumber: 1018, isUnset: { $0._groupField == nil }),
+  ]
+
 
   public static func ==(lhs: SwiftProtoTesting_Fuzz_SingularGroup_ext, rhs: SwiftProtoTesting_Fuzz_SingularGroup_ext) -> Bool {
     if lhs._groupField != rhs._groupField {return false}
@@ -5169,16 +4608,10 @@ extension SwiftProtoTesting_Fuzz_RepeatedGroup_ext: SwiftProtobuf.Message, Swift
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1048)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupField }, fieldNumber: 1048, isUnset: { $0._groupField == nil }),
+  ]
+
 
   public static func ==(lhs: SwiftProtoTesting_Fuzz_RepeatedGroup_ext, rhs: SwiftProtoTesting_Fuzz_RepeatedGroup_ext) -> Bool {
     if lhs._groupField != rhs._groupField {return false}
diff --git a/Protos/SwiftProtobufTests/generated_swift_names_enum_cases.proto b/Protos/SwiftProtobufTests/generated_swift_names_enum_cases.proto
index c259241f9..d37f669ce 100644
--- a/Protos/SwiftProtobufTests/generated_swift_names_enum_cases.proto
+++ b/Protos/SwiftProtobufTests/generated_swift_names_enum_cases.proto
@@ -282,684 +282,742 @@ enum GeneratedSwiftReservedEnum {
   EnumValueOptions = 275;
   Equatable = 276;
   Error = 277;
-  ExpressibleByArrayLiteral = 278;
-  ExpressibleByDictionaryLiteral = 279;
-  ext = 280;
-  extDecoder = 281;
-  extendedGraphemeClusterLiteral = 282;
-  ExtendedGraphemeClusterLiteralType = 283;
-  extendee = 284;
-  ExtensibleMessage = 285;
-  extension = 286;
-  ExtensionField = 287;
-  extensionFieldNumber = 288;
-  ExtensionFieldValueSet = 289;
-  ExtensionMap = 290;
-  extensionRange = 291;
-  ExtensionRangeOptions = 292;
-  extensions = 293;
-  extras = 294;
-  F = 295;
-  false = 296;
-  features = 297;
-  FeatureSet = 298;
-  FeatureSetDefaults = 299;
-  FeatureSetEditionDefault = 300;
-  field = 301;
-  fieldData = 302;
-  FieldDescriptorProto = 303;
-  FieldMask = 304;
-  fieldName = 305;
-  fieldNameCount = 306;
-  fieldNum = 307;
-  fieldNumber = 308;
-  fieldNumberForProto = 309;
-  FieldOptions = 310;
-  fieldPresence = 311;
-  fields = 312;
-  fieldSize = 313;
-  FieldTag = 314;
-  fieldType = 315;
-  file = 316;
-  FileDescriptorProto = 317;
-  FileDescriptorSet = 318;
-  fileName = 319;
-  FileOptions = 320;
-  filter = 321;
-  final = 322;
-  first = 323;
-  firstItem = 324;
-  Float = 325;
-  floatLiteral = 326;
-  FloatLiteralType = 327;
-  FloatValue = 328;
-  forMessageName = 329;
-  formUnion = 330;
-  forReadingFrom = 331;
-  forTypeURL = 332;
-  ForwardParser = 333;
-  forWritingInto = 334;
-  from = 335;
-  fromAscii2 = 336;
-  fromAscii4 = 337;
-  fromByteOffset = 338;
-  fromHexDigit = 339;
-  fullName = 340;
-  func = 341;
-  G = 342;
-  GeneratedCodeInfo = 343;
-  get = 344;
-  getExtensionValue = 345;
-  googleapis = 346;
-  Google_Protobuf_Any = 347;
-  Google_Protobuf_Api = 348;
-  Google_Protobuf_BoolValue = 349;
-  Google_Protobuf_BytesValue = 350;
-  Google_Protobuf_DescriptorProto = 351;
-  Google_Protobuf_DoubleValue = 352;
-  Google_Protobuf_Duration = 353;
-  Google_Protobuf_Edition = 354;
-  Google_Protobuf_Empty = 355;
-  Google_Protobuf_Enum = 356;
-  Google_Protobuf_EnumDescriptorProto = 357;
-  Google_Protobuf_EnumOptions = 358;
-  Google_Protobuf_EnumValue = 359;
-  Google_Protobuf_EnumValueDescriptorProto = 360;
-  Google_Protobuf_EnumValueOptions = 361;
-  Google_Protobuf_ExtensionRangeOptions = 362;
-  Google_Protobuf_FeatureSet = 363;
-  Google_Protobuf_FeatureSetDefaults = 364;
-  Google_Protobuf_Field = 365;
-  Google_Protobuf_FieldDescriptorProto = 366;
-  Google_Protobuf_FieldMask = 367;
-  Google_Protobuf_FieldOptions = 368;
-  Google_Protobuf_FileDescriptorProto = 369;
-  Google_Protobuf_FileDescriptorSet = 370;
-  Google_Protobuf_FileOptions = 371;
-  Google_Protobuf_FloatValue = 372;
-  Google_Protobuf_GeneratedCodeInfo = 373;
-  Google_Protobuf_Int32Value = 374;
-  Google_Protobuf_Int64Value = 375;
-  Google_Protobuf_ListValue = 376;
-  Google_Protobuf_MessageOptions = 377;
-  Google_Protobuf_Method = 378;
-  Google_Protobuf_MethodDescriptorProto = 379;
-  Google_Protobuf_MethodOptions = 380;
-  Google_Protobuf_Mixin = 381;
-  Google_Protobuf_NullValue = 382;
-  Google_Protobuf_OneofDescriptorProto = 383;
-  Google_Protobuf_OneofOptions = 384;
-  Google_Protobuf_Option = 385;
-  Google_Protobuf_ServiceDescriptorProto = 386;
-  Google_Protobuf_ServiceOptions = 387;
-  Google_Protobuf_SourceCodeInfo = 388;
-  Google_Protobuf_SourceContext = 389;
-  Google_Protobuf_StringValue = 390;
-  Google_Protobuf_Struct = 391;
-  Google_Protobuf_Syntax = 392;
-  Google_Protobuf_Timestamp = 393;
-  Google_Protobuf_Type = 394;
-  Google_Protobuf_UInt32Value = 395;
-  Google_Protobuf_UInt64Value = 396;
-  Google_Protobuf_UninterpretedOption = 397;
-  Google_Protobuf_Value = 398;
-  goPackage = 399;
-  group = 400;
-  groupFieldNumberStack = 401;
-  groupSize = 402;
-  hadOneofValue = 403;
-  handleConflictingOneOf = 404;
-  hasAggregateValue = 405;
-  hasAllowAlias = 406;
-  hasBegin = 407;
-  hasCcEnableArenas = 408;
-  hasCcGenericServices = 409;
-  hasClientStreaming = 410;
-  hasCsharpNamespace = 411;
-  hasCtype = 412;
-  hasDebugRedact = 413;
-  hasDefaultValue = 414;
-  hasDeprecated = 415;
-  hasDeprecatedLegacyJsonFieldConflicts = 416;
-  hasDoubleValue = 417;
-  hasEdition = 418;
-  hasEnd = 419;
-  hasEnumType = 420;
-  hasExtendee = 421;
-  hasExtensionValue = 422;
-  hasFeatures = 423;
-  hasFieldPresence = 424;
-  hasFullName = 425;
-  hasGoPackage = 426;
-  hash = 427;
-  Hashable = 428;
-  hasher = 429;
-  HashVisitor = 430;
-  hasIdempotencyLevel = 431;
-  hasIdentifierValue = 432;
-  hasInputType = 433;
-  hasIsExtension = 434;
-  hasJavaGenerateEqualsAndHash = 435;
-  hasJavaGenericServices = 436;
-  hasJavaMultipleFiles = 437;
-  hasJavaOuterClassname = 438;
-  hasJavaPackage = 439;
-  hasJavaStringCheckUtf8 = 440;
-  hasJsonFormat = 441;
-  hasJsonName = 442;
-  hasJstype = 443;
-  hasLabel = 444;
-  hasLazy = 445;
-  hasLeadingComments = 446;
-  hasMapEntry = 447;
-  hasMaximumEdition = 448;
-  hasMessageEncoding = 449;
-  hasMessageSetWireFormat = 450;
-  hasMinimumEdition = 451;
-  hasName = 452;
-  hasNamePart = 453;
-  hasNegativeIntValue = 454;
-  hasNoStandardDescriptorAccessor = 455;
-  hasNumber = 456;
-  hasObjcClassPrefix = 457;
-  hasOneofIndex = 458;
-  hasOptimizeFor = 459;
-  hasOptions = 460;
-  hasOutputType = 461;
-  hasPackage = 462;
-  hasPacked = 463;
-  hasPhpClassPrefix = 464;
-  hasPhpGenericServices = 465;
-  hasPhpMetadataNamespace = 466;
-  hasPhpNamespace = 467;
-  hasPositiveIntValue = 468;
-  hasProto3Optional = 469;
-  hasPyGenericServices = 470;
-  hasRepeated = 471;
-  hasRepeatedFieldEncoding = 472;
-  hasReserved = 473;
-  hasRetention = 474;
-  hasRubyPackage = 475;
-  hasSemantic = 476;
-  hasServerStreaming = 477;
-  hasSourceCodeInfo = 478;
-  hasSourceContext = 479;
-  hasSourceFile = 480;
-  hasStart = 481;
-  hasStringValue = 482;
-  hasSwiftPrefix = 483;
-  hasSyntax = 484;
-  hasTrailingComments = 485;
-  hasType = 486;
-  hasTypeName = 487;
-  hasUnverifiedLazy = 488;
-  hasUtf8Validation = 489;
-  hasValue = 490;
-  hasVerification = 491;
-  hasWeak = 492;
-  hour = 493;
-  i = 494;
-  idempotencyLevel = 495;
-  identifierValue = 496;
-  if = 497;
-  ignoreUnknownFields = 498;
-  index = 499;
-  init = 500;
-  inout = 501;
-  inputType = 502;
-  insert = 503;
-  Int = 504;
-  Int32 = 505;
-  Int32Value = 506;
-  Int64 = 507;
-  Int64Value = 508;
-  Int8 = 509;
-  integerLiteral = 510;
-  IntegerLiteralType = 511;
-  intern = 512;
-  Internal = 513;
-  InternalState = 514;
-  into = 515;
-  ints = 516;
-  isA = 517;
-  isEqual = 518;
-  isEqualTo = 519;
-  isExtension = 520;
-  isInitialized = 521;
-  isNegative = 522;
-  itemTagsEncodedSize = 523;
-  iterator = 524;
-  javaGenerateEqualsAndHash = 525;
-  javaGenericServices = 526;
-  javaMultipleFiles = 527;
-  javaOuterClassname = 528;
-  javaPackage = 529;
-  javaStringCheckUtf8 = 530;
-  JSONDecoder = 531;
-  JSONDecodingError = 532;
-  JSONDecodingOptions = 533;
-  jsonEncoder = 534;
-  JSONEncodingError = 535;
-  JSONEncodingOptions = 536;
-  JSONEncodingVisitor = 537;
-  jsonFormat = 538;
-  JSONMapEncodingVisitor = 539;
-  jsonName = 540;
-  jsonPath = 541;
-  jsonPaths = 542;
-  JSONScanner = 543;
-  jsonString = 544;
-  jsonText = 545;
-  jsonUTF8Bytes = 546;
-  jsonUTF8Data = 547;
-  jstype = 548;
-  k = 549;
-  kChunkSize = 550;
-  Key = 551;
-  keyField = 552;
-  keyFieldOpt = 553;
-  KeyType = 554;
-  kind = 555;
-  l = 556;
-  label = 557;
-  lazy = 558;
-  leadingComments = 559;
-  leadingDetachedComments = 560;
-  length = 561;
-  lessThan = 562;
-  let = 563;
-  lhs = 564;
-  list = 565;
-  listOfMessages = 566;
-  listValue = 567;
-  littleEndian = 568;
-  littleEndianBytes = 569;
-  load = 570;
-  localHasher = 571;
-  location = 572;
-  M = 573;
-  major = 574;
-  makeAsyncIterator = 575;
-  makeIterator = 576;
-  mapEntry = 577;
-  MapKeyType = 578;
-  mapToMessages = 579;
-  MapValueType = 580;
-  mapVisitor = 581;
-  maximumEdition = 582;
-  mdayStart = 583;
-  merge = 584;
-  message = 585;
-  messageDepthLimit = 586;
-  messageEncoding = 587;
-  MessageExtension = 588;
-  MessageImplementationBase = 589;
-  MessageOptions = 590;
-  MessageSet = 591;
-  messageSetWireFormat = 592;
-  messageSize = 593;
-  messageType = 594;
-  Method = 595;
-  MethodDescriptorProto = 596;
-  MethodOptions = 597;
-  methods = 598;
-  min = 599;
-  minimumEdition = 600;
-  minor = 601;
-  Mixin = 602;
-  mixins = 603;
-  modifier = 604;
-  modify = 605;
-  month = 606;
-  msgExtension = 607;
-  mutating = 608;
-  n = 609;
-  name = 610;
-  NameDescription = 611;
-  NameMap = 612;
-  NamePart = 613;
-  names = 614;
-  nanos = 615;
-  negativeIntValue = 616;
-  nestedType = 617;
-  newL = 618;
-  newList = 619;
-  newValue = 620;
-  next = 621;
-  nextByte = 622;
-  nextFieldNumber = 623;
-  nextVarInt = 624;
-  nil = 625;
-  nilLiteral = 626;
-  noStandardDescriptorAccessor = 627;
-  nullValue = 628;
-  number = 629;
-  numberValue = 630;
-  objcClassPrefix = 631;
-  of = 632;
-  oneofDecl = 633;
-  OneofDescriptorProto = 634;
-  oneofIndex = 635;
-  OneofOptions = 636;
-  oneofs = 637;
-  OneOf_Kind = 638;
-  optimizeFor = 639;
-  OptimizeMode = 640;
-  Option = 641;
-  OptionalEnumExtensionField = 642;
-  OptionalExtensionField = 643;
-  OptionalGroupExtensionField = 644;
-  OptionalMessageExtensionField = 645;
-  OptionRetention = 646;
-  options = 647;
-  OptionTargetType = 648;
-  other = 649;
-  others = 650;
-  out = 651;
-  outputType = 652;
-  p = 653;
-  package = 654;
-  packed = 655;
-  PackedEnumExtensionField = 656;
-  PackedExtensionField = 657;
-  padding = 658;
-  parent = 659;
-  parse = 660;
-  path = 661;
-  paths = 662;
-  payload = 663;
-  payloadSize = 664;
-  phpClassPrefix = 665;
-  phpGenericServices = 666;
-  phpMetadataNamespace = 667;
-  phpNamespace = 668;
-  pos = 669;
-  positiveIntValue = 670;
-  prefix = 671;
-  preserveProtoFieldNames = 672;
-  preTraverse = 673;
-  printUnknownFields = 674;
-  proto2 = 675;
-  proto3DefaultValue = 676;
-  proto3Optional = 677;
-  ProtobufAPIVersionCheck = 678;
-  ProtobufAPIVersion_3 = 679;
-  ProtobufBool = 680;
-  ProtobufBytes = 681;
-  ProtobufDouble = 682;
-  ProtobufEnumMap = 683;
-  protobufExtension = 684;
-  ProtobufFixed32 = 685;
-  ProtobufFixed64 = 686;
-  ProtobufFloat = 687;
-  ProtobufInt32 = 688;
-  ProtobufInt64 = 689;
-  ProtobufMap = 690;
-  ProtobufMessageMap = 691;
-  ProtobufSFixed32 = 692;
-  ProtobufSFixed64 = 693;
-  ProtobufSInt32 = 694;
-  ProtobufSInt64 = 695;
-  ProtobufString = 696;
-  ProtobufUInt32 = 697;
-  ProtobufUInt64 = 698;
-  protobuf_extensionFieldValues = 699;
-  protobuf_fieldNumber = 700;
-  protobuf_generated_isEqualTo = 701;
-  protobuf_nameMap = 702;
-  protobuf_newField = 703;
-  protobuf_package = 704;
-  protocol = 705;
-  protoFieldName = 706;
-  protoMessageName = 707;
-  ProtoNameProviding = 708;
-  protoPaths = 709;
-  public = 710;
-  publicDependency = 711;
-  putBoolValue = 712;
-  putBytesValue = 713;
-  putDoubleValue = 714;
-  putEnumValue = 715;
-  putFixedUInt32 = 716;
-  putFixedUInt64 = 717;
-  putFloatValue = 718;
-  putInt64 = 719;
-  putStringValue = 720;
-  putUInt64 = 721;
-  putUInt64Hex = 722;
-  putVarInt = 723;
-  putZigZagVarInt = 724;
-  pyGenericServices = 725;
-  R = 726;
-  rawChars = 727;
-  RawRepresentable = 728;
-  RawValue = 729;
-  read4HexDigits = 730;
-  readBytes = 731;
-  register = 732;
-  repeated = 733;
-  RepeatedEnumExtensionField = 734;
-  RepeatedExtensionField = 735;
-  repeatedFieldEncoding = 736;
-  RepeatedGroupExtensionField = 737;
-  RepeatedMessageExtensionField = 738;
-  repeating = 739;
-  requestStreaming = 740;
-  requestTypeURL = 741;
-  requiredSize = 742;
-  responseStreaming = 743;
-  responseTypeURL = 744;
-  result = 745;
-  retention = 746;
-  rethrows = 747;
-  return = 748;
-  ReturnType = 749;
-  revision = 750;
-  rhs = 751;
-  root = 752;
-  rubyPackage = 753;
-  s = 754;
-  sawBackslash = 755;
-  sawSection4Characters = 756;
-  sawSection5Characters = 757;
-  scanner = 758;
-  seconds = 759;
-  self = 760;
-  semantic = 761;
-  Sendable = 762;
-  separator = 763;
-  serialize = 764;
-  serializedBytes = 765;
-  serializedData = 766;
-  serializedSize = 767;
-  serverStreaming = 768;
-  service = 769;
-  ServiceDescriptorProto = 770;
-  ServiceOptions = 771;
-  set = 772;
-  setExtensionValue = 773;
-  shift = 774;
-  SimpleExtensionMap = 775;
-  size = 776;
-  sizer = 777;
-  source = 778;
-  sourceCodeInfo = 779;
-  sourceContext = 780;
-  sourceEncoding = 781;
-  sourceFile = 782;
-  span = 783;
-  split = 784;
-  start = 785;
-  startArray = 786;
-  startArrayObject = 787;
-  startField = 788;
-  startIndex = 789;
-  startMessageField = 790;
-  startObject = 791;
-  startRegularField = 792;
-  state = 793;
-  static = 794;
-  StaticString = 795;
-  storage = 796;
-  String = 797;
-  stringLiteral = 798;
-  StringLiteralType = 799;
-  stringResult = 800;
-  stringValue = 801;
-  struct = 802;
-  structValue = 803;
-  subDecoder = 804;
-  subscript = 805;
-  subVisitor = 806;
-  Swift = 807;
-  swiftPrefix = 808;
-  SwiftProtobufContiguousBytes = 809;
-  syntax = 810;
-  T = 811;
-  tag = 812;
-  targets = 813;
-  terminator = 814;
-  testDecoder = 815;
-  text = 816;
-  textDecoder = 817;
-  TextFormatDecoder = 818;
-  TextFormatDecodingError = 819;
-  TextFormatDecodingOptions = 820;
-  TextFormatEncodingOptions = 821;
-  TextFormatEncodingVisitor = 822;
-  textFormatString = 823;
-  throwOrIgnore = 824;
-  throws = 825;
-  timeInterval = 826;
-  timeIntervalSince1970 = 827;
-  timeIntervalSinceReferenceDate = 828;
-  Timestamp = 829;
-  total = 830;
-  totalArrayDepth = 831;
-  totalSize = 832;
-  trailingComments = 833;
-  traverse = 834;
-  true = 835;
-  try = 836;
-  type = 837;
-  typealias = 838;
-  TypeEnum = 839;
-  typeName = 840;
-  typePrefix = 841;
-  typeStart = 842;
-  typeUnknown = 843;
-  typeURL = 844;
-  UInt32 = 845;
-  UInt32Value = 846;
-  UInt64 = 847;
-  UInt64Value = 848;
-  UInt8 = 849;
-  unchecked = 850;
-  unicodeScalarLiteral = 851;
-  UnicodeScalarLiteralType = 852;
-  unicodeScalars = 853;
-  UnicodeScalarView = 854;
-  uninterpretedOption = 855;
-  union = 856;
-  uniqueStorage = 857;
-  unknown = 858;
-  unknownFields = 859;
-  UnknownStorage = 860;
-  unpackTo = 861;
-  UnsafeBufferPointer = 862;
-  UnsafeMutablePointer = 863;
-  UnsafeMutableRawBufferPointer = 864;
-  UnsafeRawBufferPointer = 865;
-  UnsafeRawPointer = 866;
-  unverifiedLazy = 867;
-  updatedOptions = 868;
-  url = 869;
-  useDeterministicOrdering = 870;
-  utf8 = 871;
-  utf8Ptr = 872;
-  utf8ToDouble = 873;
-  utf8Validation = 874;
-  UTF8View = 875;
-  v = 876;
-  value = 877;
-  valueField = 878;
-  values = 879;
-  ValueType = 880;
-  var = 881;
-  verification = 882;
-  VerificationState = 883;
-  Version = 884;
-  versionString = 885;
-  visitExtensionFields = 886;
-  visitExtensionFieldsAsMessageSet = 887;
-  visitMapField = 888;
-  visitor = 889;
-  visitPacked = 890;
-  visitPackedBoolField = 891;
-  visitPackedDoubleField = 892;
-  visitPackedEnumField = 893;
-  visitPackedFixed32Field = 894;
-  visitPackedFixed64Field = 895;
-  visitPackedFloatField = 896;
-  visitPackedInt32Field = 897;
-  visitPackedInt64Field = 898;
-  visitPackedSFixed32Field = 899;
-  visitPackedSFixed64Field = 900;
-  visitPackedSInt32Field = 901;
-  visitPackedSInt64Field = 902;
-  visitPackedUInt32Field = 903;
-  visitPackedUInt64Field = 904;
-  visitRepeated = 905;
-  visitRepeatedBoolField = 906;
-  visitRepeatedBytesField = 907;
-  visitRepeatedDoubleField = 908;
-  visitRepeatedEnumField = 909;
-  visitRepeatedFixed32Field = 910;
-  visitRepeatedFixed64Field = 911;
-  visitRepeatedFloatField = 912;
-  visitRepeatedGroupField = 913;
-  visitRepeatedInt32Field = 914;
-  visitRepeatedInt64Field = 915;
-  visitRepeatedMessageField = 916;
-  visitRepeatedSFixed32Field = 917;
-  visitRepeatedSFixed64Field = 918;
-  visitRepeatedSInt32Field = 919;
-  visitRepeatedSInt64Field = 920;
-  visitRepeatedStringField = 921;
-  visitRepeatedUInt32Field = 922;
-  visitRepeatedUInt64Field = 923;
-  visitSingular = 924;
-  visitSingularBoolField = 925;
-  visitSingularBytesField = 926;
-  visitSingularDoubleField = 927;
-  visitSingularEnumField = 928;
-  visitSingularFixed32Field = 929;
-  visitSingularFixed64Field = 930;
-  visitSingularFloatField = 931;
-  visitSingularGroupField = 932;
-  visitSingularInt32Field = 933;
-  visitSingularInt64Field = 934;
-  visitSingularMessageField = 935;
-  visitSingularSFixed32Field = 936;
-  visitSingularSFixed64Field = 937;
-  visitSingularSInt32Field = 938;
-  visitSingularSInt64Field = 939;
-  visitSingularStringField = 940;
-  visitSingularUInt32Field = 941;
-  visitSingularUInt64Field = 942;
-  visitUnknown = 943;
-  wasDecoded = 944;
-  weak = 945;
-  weakDependency = 946;
-  where = 947;
-  wireFormat = 948;
-  with = 949;
-  withUnsafeBytes = 950;
-  withUnsafeMutableBytes = 951;
-  work = 952;
-  Wrapped = 953;
-  WrappedType = 954;
-  wrappedValue = 955;
-  written = 956;
-  yday = 957;
+  escaping = 278;
+  ExpressibleByArrayLiteral = 279;
+  ExpressibleByDictionaryLiteral = 280;
+  ext = 281;
+  extDecoder = 282;
+  extendedGraphemeClusterLiteral = 283;
+  ExtendedGraphemeClusterLiteralType = 284;
+  extendee = 285;
+  ExtensibleMessage = 286;
+  extension = 287;
+  ExtensionField = 288;
+  extensionFieldNumber = 289;
+  extensionFields = 290;
+  extensionFieldsAsMessageSet = 291;
+  ExtensionFieldValueSet = 292;
+  ExtensionMap = 293;
+  extensionRange = 294;
+  ExtensionRangeOptions = 295;
+  extensions = 296;
+  extras = 297;
+  F = 298;
+  false = 299;
+  features = 300;
+  FeatureSet = 301;
+  FeatureSetDefaults = 302;
+  FeatureSetEditionDefault = 303;
+  field = 304;
+  fieldData = 305;
+  FieldDescriptorProto = 306;
+  FieldMask = 307;
+  fieldName = 308;
+  fieldNameCount = 309;
+  fieldNum = 310;
+  fieldNumber = 311;
+  fieldNumberForProto = 312;
+  FieldOptions = 313;
+  fieldPresence = 314;
+  fields = 315;
+  fieldSize = 316;
+  FieldTag = 317;
+  fieldType = 318;
+  file = 319;
+  FileDescriptorProto = 320;
+  FileDescriptorSet = 321;
+  fileName = 322;
+  FileOptions = 323;
+  filter = 324;
+  final = 325;
+  first = 326;
+  firstItem = 327;
+  Float = 328;
+  floatLiteral = 329;
+  FloatLiteralType = 330;
+  FloatValue = 331;
+  forMessageName = 332;
+  formUnion = 333;
+  forReadingFrom = 334;
+  forTypeURL = 335;
+  ForwardParser = 336;
+  forWritingInto = 337;
+  from = 338;
+  fromAscii2 = 339;
+  fromAscii4 = 340;
+  fromByteOffset = 341;
+  fromHexDigit = 342;
+  fullName = 343;
+  func = 344;
+  G = 345;
+  GeneratedCodeInfo = 346;
+  get = 347;
+  getExtensionValue = 348;
+  getValue = 349;
+  googleapis = 350;
+  Google_Protobuf_Any = 351;
+  Google_Protobuf_Api = 352;
+  Google_Protobuf_BoolValue = 353;
+  Google_Protobuf_BytesValue = 354;
+  Google_Protobuf_DescriptorProto = 355;
+  Google_Protobuf_DoubleValue = 356;
+  Google_Protobuf_Duration = 357;
+  Google_Protobuf_Edition = 358;
+  Google_Protobuf_Empty = 359;
+  Google_Protobuf_Enum = 360;
+  Google_Protobuf_EnumDescriptorProto = 361;
+  Google_Protobuf_EnumOptions = 362;
+  Google_Protobuf_EnumValue = 363;
+  Google_Protobuf_EnumValueDescriptorProto = 364;
+  Google_Protobuf_EnumValueOptions = 365;
+  Google_Protobuf_ExtensionRangeOptions = 366;
+  Google_Protobuf_FeatureSet = 367;
+  Google_Protobuf_FeatureSetDefaults = 368;
+  Google_Protobuf_Field = 369;
+  Google_Protobuf_FieldDescriptorProto = 370;
+  Google_Protobuf_FieldMask = 371;
+  Google_Protobuf_FieldOptions = 372;
+  Google_Protobuf_FileDescriptorProto = 373;
+  Google_Protobuf_FileDescriptorSet = 374;
+  Google_Protobuf_FileOptions = 375;
+  Google_Protobuf_FloatValue = 376;
+  Google_Protobuf_GeneratedCodeInfo = 377;
+  Google_Protobuf_Int32Value = 378;
+  Google_Protobuf_Int64Value = 379;
+  Google_Protobuf_ListValue = 380;
+  Google_Protobuf_MessageOptions = 381;
+  Google_Protobuf_Method = 382;
+  Google_Protobuf_MethodDescriptorProto = 383;
+  Google_Protobuf_MethodOptions = 384;
+  Google_Protobuf_Mixin = 385;
+  Google_Protobuf_NullValue = 386;
+  Google_Protobuf_OneofDescriptorProto = 387;
+  Google_Protobuf_OneofOptions = 388;
+  Google_Protobuf_Option = 389;
+  Google_Protobuf_ServiceDescriptorProto = 390;
+  Google_Protobuf_ServiceOptions = 391;
+  Google_Protobuf_SourceCodeInfo = 392;
+  Google_Protobuf_SourceContext = 393;
+  Google_Protobuf_StringValue = 394;
+  Google_Protobuf_Struct = 395;
+  Google_Protobuf_Syntax = 396;
+  Google_Protobuf_Timestamp = 397;
+  Google_Protobuf_Type = 398;
+  Google_Protobuf_UInt32Value = 399;
+  Google_Protobuf_UInt64Value = 400;
+  Google_Protobuf_UninterpretedOption = 401;
+  Google_Protobuf_Value = 402;
+  goPackage = 403;
+  group = 404;
+  groupFieldNumberStack = 405;
+  groupSize = 406;
+  hadOneofValue = 407;
+  handleConflictingOneOf = 408;
+  hasAggregateValue = 409;
+  hasAllowAlias = 410;
+  hasBegin = 411;
+  hasCcEnableArenas = 412;
+  hasCcGenericServices = 413;
+  hasClientStreaming = 414;
+  hasCsharpNamespace = 415;
+  hasCtype = 416;
+  hasDebugRedact = 417;
+  hasDefaultValue = 418;
+  hasDeprecated = 419;
+  hasDeprecatedLegacyJsonFieldConflicts = 420;
+  hasDoubleValue = 421;
+  hasEdition = 422;
+  hasEnd = 423;
+  hasEnumType = 424;
+  hasExtendee = 425;
+  hasExtensionValue = 426;
+  hasFeatures = 427;
+  hasFieldPresence = 428;
+  hasFullName = 429;
+  hasGoPackage = 430;
+  hash = 431;
+  Hashable = 432;
+  hasher = 433;
+  HashVisitor = 434;
+  hasIdempotencyLevel = 435;
+  hasIdentifierValue = 436;
+  hasInputType = 437;
+  hasIsExtension = 438;
+  hasJavaGenerateEqualsAndHash = 439;
+  hasJavaGenericServices = 440;
+  hasJavaMultipleFiles = 441;
+  hasJavaOuterClassname = 442;
+  hasJavaPackage = 443;
+  hasJavaStringCheckUtf8 = 444;
+  hasJsonFormat = 445;
+  hasJsonName = 446;
+  hasJstype = 447;
+  hasLabel = 448;
+  hasLazy = 449;
+  hasLeadingComments = 450;
+  hasMapEntry = 451;
+  hasMaximumEdition = 452;
+  hasMessageEncoding = 453;
+  hasMessageSetWireFormat = 454;
+  hasMinimumEdition = 455;
+  hasName = 456;
+  hasNamePart = 457;
+  hasNegativeIntValue = 458;
+  hasNoStandardDescriptorAccessor = 459;
+  hasNumber = 460;
+  hasObjcClassPrefix = 461;
+  hasOneofIndex = 462;
+  hasOptimizeFor = 463;
+  hasOptions = 464;
+  hasOutputType = 465;
+  hasPackage = 466;
+  hasPacked = 467;
+  hasPhpClassPrefix = 468;
+  hasPhpGenericServices = 469;
+  hasPhpMetadataNamespace = 470;
+  hasPhpNamespace = 471;
+  hasPositiveIntValue = 472;
+  hasProto3Optional = 473;
+  hasPyGenericServices = 474;
+  hasRepeated = 475;
+  hasRepeatedFieldEncoding = 476;
+  hasReserved = 477;
+  hasRetention = 478;
+  hasRubyPackage = 479;
+  hasSemantic = 480;
+  hasServerStreaming = 481;
+  hasSourceCodeInfo = 482;
+  hasSourceContext = 483;
+  hasSourceFile = 484;
+  hasStart = 485;
+  hasStringValue = 486;
+  hasSwiftPrefix = 487;
+  hasSyntax = 488;
+  hasTrailingComments = 489;
+  hasType = 490;
+  hasTypeName = 491;
+  hasUnverifiedLazy = 492;
+  hasUtf8Validation = 493;
+  hasValue = 494;
+  hasVerification = 495;
+  hasWeak = 496;
+  hour = 497;
+  i = 498;
+  idempotencyLevel = 499;
+  identifierValue = 500;
+  if = 501;
+  ignoreUnknownFields = 502;
+  index = 503;
+  init = 504;
+  inout = 505;
+  inputType = 506;
+  insert = 507;
+  Int = 508;
+  Int32 = 509;
+  Int32Value = 510;
+  Int64 = 511;
+  Int64Value = 512;
+  Int8 = 513;
+  integerLiteral = 514;
+  IntegerLiteralType = 515;
+  intern = 516;
+  Internal = 517;
+  InternalState = 518;
+  into = 519;
+  ints = 520;
+  isA = 521;
+  isEqual = 522;
+  isEqualTo = 523;
+  isExtension = 524;
+  isInitialized = 525;
+  isNegative = 526;
+  isUnset = 527;
+  itemTagsEncodedSize = 528;
+  iterator = 529;
+  javaGenerateEqualsAndHash = 530;
+  javaGenericServices = 531;
+  javaMultipleFiles = 532;
+  javaOuterClassname = 533;
+  javaPackage = 534;
+  javaStringCheckUtf8 = 535;
+  JSONDecoder = 536;
+  JSONDecodingError = 537;
+  JSONDecodingOptions = 538;
+  jsonEncoder = 539;
+  JSONEncodingError = 540;
+  JSONEncodingOptions = 541;
+  JSONEncodingVisitor = 542;
+  jsonFormat = 543;
+  JSONMapEncodingVisitor = 544;
+  jsonName = 545;
+  jsonPath = 546;
+  jsonPaths = 547;
+  JSONScanner = 548;
+  jsonString = 549;
+  jsonText = 550;
+  jsonUTF8Bytes = 551;
+  jsonUTF8Data = 552;
+  jstype = 553;
+  k = 554;
+  kChunkSize = 555;
+  Key = 556;
+  keyField = 557;
+  keyFieldOpt = 558;
+  KeyType = 559;
+  kind = 560;
+  l = 561;
+  label = 562;
+  lazy = 563;
+  leadingComments = 564;
+  leadingDetachedComments = 565;
+  length = 566;
+  lessThan = 567;
+  let = 568;
+  lhs = 569;
+  list = 570;
+  listOfMessages = 571;
+  listValue = 572;
+  littleEndian = 573;
+  littleEndianBytes = 574;
+  load = 575;
+  localHasher = 576;
+  location = 577;
+  M = 578;
+  major = 579;
+  makeAsyncIterator = 580;
+  makeIterator = 581;
+  map = 582;
+  mapEntry = 583;
+  MapKeyType = 584;
+  mapToMessages = 585;
+  MapValueType = 586;
+  mapVisitor = 587;
+  maximumEdition = 588;
+  mdayStart = 589;
+  merge = 590;
+  message = 591;
+  messageDepthLimit = 592;
+  messageEncoding = 593;
+  MessageExtension = 594;
+  MessageImplementationBase = 595;
+  MessageOptions = 596;
+  MessageSet = 597;
+  messageSetWireFormat = 598;
+  messageSize = 599;
+  messageType = 600;
+  Method = 601;
+  MethodDescriptorProto = 602;
+  MethodOptions = 603;
+  methods = 604;
+  min = 605;
+  minimumEdition = 606;
+  minor = 607;
+  Mixin = 608;
+  mixins = 609;
+  modifier = 610;
+  modify = 611;
+  month = 612;
+  msgExtension = 613;
+  mutating = 614;
+  n = 615;
+  name = 616;
+  NameDescription = 617;
+  NameMap = 618;
+  NamePart = 619;
+  names = 620;
+  nanos = 621;
+  negativeIntValue = 622;
+  nestedType = 623;
+  newL = 624;
+  newList = 625;
+  newValue = 626;
+  next = 627;
+  nextByte = 628;
+  nextFieldNumber = 629;
+  nextVarInt = 630;
+  nil = 631;
+  nilLiteral = 632;
+  noStandardDescriptorAccessor = 633;
+  nullValue = 634;
+  number = 635;
+  numberValue = 636;
+  objcClassPrefix = 637;
+  of = 638;
+  oneOf = 639;
+  oneofDecl = 640;
+  OneofDescriptorProto = 641;
+  oneofIndex = 642;
+  OneofOptions = 643;
+  oneofs = 644;
+  OneOf_Kind = 645;
+  optimizeFor = 646;
+  OptimizeMode = 647;
+  Option = 648;
+  OptionalEnumExtensionField = 649;
+  OptionalExtensionField = 650;
+  OptionalGroupExtensionField = 651;
+  OptionalMessageExtensionField = 652;
+  OptionRetention = 653;
+  options = 654;
+  OptionTargetType = 655;
+  other = 656;
+  others = 657;
+  out = 658;
+  outputType = 659;
+  p = 660;
+  package = 661;
+  packed = 662;
+  packedBool = 663;
+  packedDouble = 664;
+  packedEnum = 665;
+  PackedEnumExtensionField = 666;
+  PackedExtensionField = 667;
+  packedFixed32 = 668;
+  packedFixed64 = 669;
+  packedFloat = 670;
+  packedInt32 = 671;
+  packedInt64 = 672;
+  packedSFixed32 = 673;
+  packedSFixed64 = 674;
+  packedSInt32 = 675;
+  packedSInt64 = 676;
+  packedUInt32 = 677;
+  packedUInt64 = 678;
+  padding = 679;
+  parent = 680;
+  parse = 681;
+  path = 682;
+  paths = 683;
+  payload = 684;
+  payloadSize = 685;
+  phpClassPrefix = 686;
+  phpGenericServices = 687;
+  phpMetadataNamespace = 688;
+  phpNamespace = 689;
+  pos = 690;
+  positiveIntValue = 691;
+  prefix = 692;
+  preserveProtoFieldNames = 693;
+  preTraverse = 694;
+  printUnknownFields = 695;
+  proto2 = 696;
+  proto3DefaultValue = 697;
+  proto3Optional = 698;
+  ProtobufAPIVersionCheck = 699;
+  ProtobufAPIVersion_3 = 700;
+  ProtobufBool = 701;
+  ProtobufBytes = 702;
+  ProtobufDouble = 703;
+  ProtobufEnumMap = 704;
+  protobufExtension = 705;
+  ProtobufFixed32 = 706;
+  ProtobufFixed64 = 707;
+  ProtobufFloat = 708;
+  ProtobufInt32 = 709;
+  ProtobufInt64 = 710;
+  ProtobufMap = 711;
+  ProtobufMessageMap = 712;
+  ProtobufSFixed32 = 713;
+  ProtobufSFixed64 = 714;
+  ProtobufSInt32 = 715;
+  ProtobufSInt64 = 716;
+  ProtobufString = 717;
+  ProtobufUInt32 = 718;
+  ProtobufUInt64 = 719;
+  protobuf_extensionFieldValues = 720;
+  protobuf_fieldNumber = 721;
+  protobuf_generated_isEqualTo = 722;
+  protobuf_nameMap = 723;
+  protobuf_newField = 724;
+  protobuf_package = 725;
+  protocol = 726;
+  protoFieldName = 727;
+  protoMessageName = 728;
+  ProtoNameProviding = 729;
+  protoPaths = 730;
+  public = 731;
+  publicDependency = 732;
+  putBoolValue = 733;
+  putBytesValue = 734;
+  putDoubleValue = 735;
+  putEnumValue = 736;
+  putFixedUInt32 = 737;
+  putFixedUInt64 = 738;
+  putFloatValue = 739;
+  putInt64 = 740;
+  putStringValue = 741;
+  putUInt64 = 742;
+  putUInt64Hex = 743;
+  putVarInt = 744;
+  putZigZagVarInt = 745;
+  pyGenericServices = 746;
+  R = 747;
+  rawChars = 748;
+  RawRepresentable = 749;
+  RawValue = 750;
+  read4HexDigits = 751;
+  readBytes = 752;
+  register = 753;
+  repeated = 754;
+  repeatedBool = 755;
+  repeatedBytes = 756;
+  repeatedDouble = 757;
+  repeatedEnum = 758;
+  RepeatedEnumExtensionField = 759;
+  RepeatedExtensionField = 760;
+  repeatedFieldEncoding = 761;
+  repeatedFixed32 = 762;
+  repeatedFixed64 = 763;
+  repeatedFloat = 764;
+  repeatedGroup = 765;
+  RepeatedGroupExtensionField = 766;
+  repeatedInt32 = 767;
+  repeatedInt64 = 768;
+  repeatedMessage = 769;
+  RepeatedMessageExtensionField = 770;
+  repeatedSFixed32 = 771;
+  repeatedSFixed64 = 772;
+  repeatedSInt32 = 773;
+  repeatedSInt64 = 774;
+  repeatedString = 775;
+  repeatedUInt32 = 776;
+  repeatedUInt64 = 777;
+  repeating = 778;
+  requestStreaming = 779;
+  requestTypeURL = 780;
+  requiredSize = 781;
+  responseStreaming = 782;
+  responseTypeURL = 783;
+  result = 784;
+  retention = 785;
+  rethrows = 786;
+  return = 787;
+  ReturnType = 788;
+  revision = 789;
+  rhs = 790;
+  root = 791;
+  rubyPackage = 792;
+  s = 793;
+  sawBackslash = 794;
+  sawSection4Characters = 795;
+  sawSection5Characters = 796;
+  scanner = 797;
+  seconds = 798;
+  self = 799;
+  semantic = 800;
+  Sendable = 801;
+  separator = 802;
+  serialize = 803;
+  serializedBytes = 804;
+  serializedData = 805;
+  serializedSize = 806;
+  serverStreaming = 807;
+  service = 808;
+  ServiceDescriptorProto = 809;
+  ServiceOptions = 810;
+  set = 811;
+  setExtensionValue = 812;
+  shift = 813;
+  SimpleExtensionMap = 814;
+  singularBool = 815;
+  singularBytes = 816;
+  singularDouble = 817;
+  singularEnum = 818;
+  singularFixed32 = 819;
+  singularFixed64 = 820;
+  singularFloat = 821;
+  singularGroup = 822;
+  singularInt32 = 823;
+  singularInt64 = 824;
+  singularMessage = 825;
+  singularSFixed32 = 826;
+  singularSFixed64 = 827;
+  singularSInt32 = 828;
+  singularSInt64 = 829;
+  singularString = 830;
+  singularUInt32 = 831;
+  singularUInt64 = 832;
+  size = 833;
+  sizer = 834;
+  source = 835;
+  sourceCodeInfo = 836;
+  sourceContext = 837;
+  sourceEncoding = 838;
+  sourceFile = 839;
+  span = 840;
+  split = 841;
+  start = 842;
+  startArray = 843;
+  startArrayObject = 844;
+  startField = 845;
+  startIndex = 846;
+  startMessageField = 847;
+  startObject = 848;
+  startRegularField = 849;
+  state = 850;
+  static = 851;
+  StaticString = 852;
+  storage = 853;
+  String = 854;
+  stringLiteral = 855;
+  StringLiteralType = 856;
+  stringResult = 857;
+  stringValue = 858;
+  struct = 859;
+  structValue = 860;
+  subDecoder = 861;
+  subscript = 862;
+  subVisitor = 863;
+  Swift = 864;
+  swiftPrefix = 865;
+  SwiftProtobufContiguousBytes = 866;
+  syntax = 867;
+  T = 868;
+  tag = 869;
+  targets = 870;
+  terminator = 871;
+  testDecoder = 872;
+  text = 873;
+  textDecoder = 874;
+  TextFormatDecoder = 875;
+  TextFormatDecodingError = 876;
+  TextFormatDecodingOptions = 877;
+  TextFormatEncodingOptions = 878;
+  TextFormatEncodingVisitor = 879;
+  textFormatString = 880;
+  throwOrIgnore = 881;
+  throws = 882;
+  timeInterval = 883;
+  timeIntervalSince1970 = 884;
+  timeIntervalSinceReferenceDate = 885;
+  Timestamp = 886;
+  toConcrete = 887;
+  total = 888;
+  totalArrayDepth = 889;
+  totalSize = 890;
+  trailingComments = 891;
+  traverse = 892;
+  true = 893;
+  try = 894;
+  type = 895;
+  typealias = 896;
+  TypeEnum = 897;
+  typeName = 898;
+  typePrefix = 899;
+  typeStart = 900;
+  typeUnknown = 901;
+  typeURL = 902;
+  UInt32 = 903;
+  UInt32Value = 904;
+  UInt64 = 905;
+  UInt64Value = 906;
+  UInt8 = 907;
+  unchecked = 908;
+  unicodeScalarLiteral = 909;
+  UnicodeScalarLiteralType = 910;
+  unicodeScalars = 911;
+  UnicodeScalarView = 912;
+  uninterpretedOption = 913;
+  union = 914;
+  uniqueStorage = 915;
+  unknown = 916;
+  unknownFields = 917;
+  UnknownStorage = 918;
+  unpackTo = 919;
+  UnsafeBufferPointer = 920;
+  UnsafeMutablePointer = 921;
+  UnsafeMutableRawBufferPointer = 922;
+  UnsafeRawBufferPointer = 923;
+  UnsafeRawPointer = 924;
+  unverifiedLazy = 925;
+  updatedOptions = 926;
+  url = 927;
+  useDeterministicOrdering = 928;
+  utf8 = 929;
+  utf8Ptr = 930;
+  utf8ToDouble = 931;
+  utf8Validation = 932;
+  UTF8View = 933;
+  v = 934;
+  value = 935;
+  valueField = 936;
+  values = 937;
+  ValueType = 938;
+  var = 939;
+  verification = 940;
+  VerificationState = 941;
+  Version = 942;
+  versionString = 943;
+  visitExtensionFields = 944;
+  visitExtensionFieldsAsMessageSet = 945;
+  visitMapField = 946;
+  visitor = 947;
+  visitPacked = 948;
+  visitPackedBoolField = 949;
+  visitPackedDoubleField = 950;
+  visitPackedEnumField = 951;
+  visitPackedFixed32Field = 952;
+  visitPackedFixed64Field = 953;
+  visitPackedFloatField = 954;
+  visitPackedInt32Field = 955;
+  visitPackedInt64Field = 956;
+  visitPackedSFixed32Field = 957;
+  visitPackedSFixed64Field = 958;
+  visitPackedSInt32Field = 959;
+  visitPackedSInt64Field = 960;
+  visitPackedUInt32Field = 961;
+  visitPackedUInt64Field = 962;
+  visitRepeated = 963;
+  visitRepeatedBoolField = 964;
+  visitRepeatedBytesField = 965;
+  visitRepeatedDoubleField = 966;
+  visitRepeatedEnumField = 967;
+  visitRepeatedFixed32Field = 968;
+  visitRepeatedFixed64Field = 969;
+  visitRepeatedFloatField = 970;
+  visitRepeatedGroupField = 971;
+  visitRepeatedInt32Field = 972;
+  visitRepeatedInt64Field = 973;
+  visitRepeatedMessageField = 974;
+  visitRepeatedSFixed32Field = 975;
+  visitRepeatedSFixed64Field = 976;
+  visitRepeatedSInt32Field = 977;
+  visitRepeatedSInt64Field = 978;
+  visitRepeatedStringField = 979;
+  visitRepeatedUInt32Field = 980;
+  visitRepeatedUInt64Field = 981;
+  visitSingular = 982;
+  visitSingularBoolField = 983;
+  visitSingularBytesField = 984;
+  visitSingularDoubleField = 985;
+  visitSingularEnumField = 986;
+  visitSingularFixed32Field = 987;
+  visitSingularFixed64Field = 988;
+  visitSingularFloatField = 989;
+  visitSingularGroupField = 990;
+  visitSingularInt32Field = 991;
+  visitSingularInt64Field = 992;
+  visitSingularMessageField = 993;
+  visitSingularSFixed32Field = 994;
+  visitSingularSFixed64Field = 995;
+  visitSingularSInt32Field = 996;
+  visitSingularSInt64Field = 997;
+  visitSingularStringField = 998;
+  visitSingularUInt32Field = 999;
+  visitSingularUInt64Field = 1000;
+  visitUnknown = 1001;
+  wasDecoded = 1002;
+  weak = 1003;
+  weakDependency = 1004;
+  where = 1005;
+  wireFormat = 1006;
+  with = 1007;
+  withUnsafeBytes = 1008;
+  withUnsafeMutableBytes = 1009;
+  work = 1010;
+  Wrapped = 1011;
+  WrappedType = 1012;
+  wrappedValue = 1013;
+  written = 1014;
+  yday = 1015;
 }
diff --git a/Protos/SwiftProtobufTests/generated_swift_names_enums.proto b/Protos/SwiftProtobufTests/generated_swift_names_enums.proto
index 64bb9013c..db220d40c 100644
--- a/Protos/SwiftProtobufTests/generated_swift_names_enums.proto
+++ b/Protos/SwiftProtobufTests/generated_swift_names_enums.proto
@@ -281,6 +281,7 @@ message GeneratedSwiftReservedEnums {
   enum EnumValueOptions { NONE_EnumValueOptions = 0; }
   enum Equatable { NONE_Equatable = 0; }
   enum Error { NONE_Error = 0; }
+  enum escaping { NONE_escaping = 0; }
   enum ExpressibleByArrayLiteral { NONE_ExpressibleByArrayLiteral = 0; }
   enum ExpressibleByDictionaryLiteral { NONE_ExpressibleByDictionaryLiteral = 0; }
   enum ext { NONE_ext = 0; }
@@ -292,6 +293,8 @@ message GeneratedSwiftReservedEnums {
   enum extension { NONE_extension = 0; }
   enum ExtensionField { NONE_ExtensionField = 0; }
   enum extensionFieldNumber { NONE_extensionFieldNumber = 0; }
+  enum extensionFields { NONE_extensionFields = 0; }
+  enum extensionFieldsAsMessageSet { NONE_extensionFieldsAsMessageSet = 0; }
   enum ExtensionFieldValueSet { NONE_ExtensionFieldValueSet = 0; }
   enum ExtensionMap { NONE_ExtensionMap = 0; }
   enum extensionRange { NONE_extensionRange = 0; }
@@ -349,6 +352,7 @@ message GeneratedSwiftReservedEnums {
   enum GeneratedCodeInfo { NONE_GeneratedCodeInfo = 0; }
   enum get { NONE_get = 0; }
   enum getExtensionValue { NONE_getExtensionValue = 0; }
+  enum getValue { NONE_getValue = 0; }
   enum googleapis { NONE_googleapis = 0; }
   enum Google_Protobuf_Any { NONE_Google_Protobuf_Any = 0; }
   enum Google_Protobuf_Api { NONE_Google_Protobuf_Api = 0; }
@@ -526,6 +530,7 @@ message GeneratedSwiftReservedEnums {
   enum isExtension { NONE_isExtension = 0; }
   enum isInitialized { NONE_isInitialized = 0; }
   enum isNegative { NONE_isNegative = 0; }
+  enum isUnset { NONE_isUnset = 0; }
   enum itemTagsEncodedSize { NONE_itemTagsEncodedSize = 0; }
   enum iterator { NONE_iterator = 0; }
   enum javaGenerateEqualsAndHash { NONE_javaGenerateEqualsAndHash = 0; }
@@ -580,6 +585,7 @@ message GeneratedSwiftReservedEnums {
   enum major { NONE_major = 0; }
   enum makeAsyncIterator { NONE_makeAsyncIterator = 0; }
   enum makeIterator { NONE_makeIterator = 0; }
+  enum map { NONE_map = 0; }
   enum mapEntry { NONE_mapEntry = 0; }
   enum MapKeyType { NONE_MapKeyType = 0; }
   enum mapToMessages { NONE_mapToMessages = 0; }
@@ -636,6 +642,7 @@ message GeneratedSwiftReservedEnums {
   enum numberValue { NONE_numberValue = 0; }
   enum objcClassPrefix { NONE_objcClassPrefix = 0; }
   enum of { NONE_of = 0; }
+  enum oneOf { NONE_oneOf = 0; }
   enum oneofDecl { NONE_oneofDecl = 0; }
   enum OneofDescriptorProto { NONE_OneofDescriptorProto = 0; }
   enum oneofIndex { NONE_oneofIndex = 0; }
@@ -659,8 +666,22 @@ message GeneratedSwiftReservedEnums {
   enum p { NONE_p = 0; }
   enum package { NONE_package = 0; }
   enum packed { NONE_packed = 0; }
+  enum packedBool { NONE_packedBool = 0; }
+  enum packedDouble { NONE_packedDouble = 0; }
+  enum packedEnum { NONE_packedEnum = 0; }
   enum PackedEnumExtensionField { NONE_PackedEnumExtensionField = 0; }
   enum PackedExtensionField { NONE_PackedExtensionField = 0; }
+  enum packedFixed32 { NONE_packedFixed32 = 0; }
+  enum packedFixed64 { NONE_packedFixed64 = 0; }
+  enum packedFloat { NONE_packedFloat = 0; }
+  enum packedInt32 { NONE_packedInt32 = 0; }
+  enum packedInt64 { NONE_packedInt64 = 0; }
+  enum packedSFixed32 { NONE_packedSFixed32 = 0; }
+  enum packedSFixed64 { NONE_packedSFixed64 = 0; }
+  enum packedSInt32 { NONE_packedSInt32 = 0; }
+  enum packedSInt64 { NONE_packedSInt64 = 0; }
+  enum packedUInt32 { NONE_packedUInt32 = 0; }
+  enum packedUInt64 { NONE_packedUInt64 = 0; }
   enum padding { NONE_padding = 0; }
   enum parent { NONE_parent = 0; }
   enum parse { NONE_parse = 0; }
@@ -737,11 +758,29 @@ message GeneratedSwiftReservedEnums {
   enum readBytes { NONE_readBytes = 0; }
   enum register { NONE_register = 0; }
   enum repeated { NONE_repeated = 0; }
+  enum repeatedBool { NONE_repeatedBool = 0; }
+  enum repeatedBytes { NONE_repeatedBytes = 0; }
+  enum repeatedDouble { NONE_repeatedDouble = 0; }
+  enum repeatedEnum { NONE_repeatedEnum = 0; }
   enum RepeatedEnumExtensionField { NONE_RepeatedEnumExtensionField = 0; }
   enum RepeatedExtensionField { NONE_RepeatedExtensionField = 0; }
   enum repeatedFieldEncoding { NONE_repeatedFieldEncoding = 0; }
+  enum repeatedFixed32 { NONE_repeatedFixed32 = 0; }
+  enum repeatedFixed64 { NONE_repeatedFixed64 = 0; }
+  enum repeatedFloat { NONE_repeatedFloat = 0; }
+  enum repeatedGroup { NONE_repeatedGroup = 0; }
   enum RepeatedGroupExtensionField { NONE_RepeatedGroupExtensionField = 0; }
+  enum repeatedInt32 { NONE_repeatedInt32 = 0; }
+  enum repeatedInt64 { NONE_repeatedInt64 = 0; }
+  enum repeatedMessage { NONE_repeatedMessage = 0; }
   enum RepeatedMessageExtensionField { NONE_RepeatedMessageExtensionField = 0; }
+  enum repeatedSFixed32 { NONE_repeatedSFixed32 = 0; }
+  enum repeatedSFixed64 { NONE_repeatedSFixed64 = 0; }
+  enum repeatedSInt32 { NONE_repeatedSInt32 = 0; }
+  enum repeatedSInt64 { NONE_repeatedSInt64 = 0; }
+  enum repeatedString { NONE_repeatedString = 0; }
+  enum repeatedUInt32 { NONE_repeatedUInt32 = 0; }
+  enum repeatedUInt64 { NONE_repeatedUInt64 = 0; }
   enum repeating { NONE_repeating = 0; }
   enum requestStreaming { NONE_requestStreaming = 0; }
   enum requestTypeURL { NONE_requestTypeURL = 0; }
@@ -779,6 +818,24 @@ message GeneratedSwiftReservedEnums {
   enum setExtensionValue { NONE_setExtensionValue = 0; }
   enum shift { NONE_shift = 0; }
   enum SimpleExtensionMap { NONE_SimpleExtensionMap = 0; }
+  enum singularBool { NONE_singularBool = 0; }
+  enum singularBytes { NONE_singularBytes = 0; }
+  enum singularDouble { NONE_singularDouble = 0; }
+  enum singularEnum { NONE_singularEnum = 0; }
+  enum singularFixed32 { NONE_singularFixed32 = 0; }
+  enum singularFixed64 { NONE_singularFixed64 = 0; }
+  enum singularFloat { NONE_singularFloat = 0; }
+  enum singularGroup { NONE_singularGroup = 0; }
+  enum singularInt32 { NONE_singularInt32 = 0; }
+  enum singularInt64 { NONE_singularInt64 = 0; }
+  enum singularMessage { NONE_singularMessage = 0; }
+  enum singularSFixed32 { NONE_singularSFixed32 = 0; }
+  enum singularSFixed64 { NONE_singularSFixed64 = 0; }
+  enum singularSInt32 { NONE_singularSInt32 = 0; }
+  enum singularSInt64 { NONE_singularSInt64 = 0; }
+  enum singularString { NONE_singularString = 0; }
+  enum singularUInt32 { NONE_singularUInt32 = 0; }
+  enum singularUInt64 { NONE_singularUInt64 = 0; }
   enum size { NONE_size = 0; }
   enum sizer { NONE_sizer = 0; }
   enum source { NONE_source = 0; }
@@ -833,6 +890,7 @@ message GeneratedSwiftReservedEnums {
   enum timeIntervalSince1970 { NONE_timeIntervalSince1970 = 0; }
   enum timeIntervalSinceReferenceDate { NONE_timeIntervalSinceReferenceDate = 0; }
   enum Timestamp { NONE_Timestamp = 0; }
+  enum toConcrete { NONE_toConcrete = 0; }
   enum total { NONE_total = 0; }
   enum totalArrayDepth { NONE_totalArrayDepth = 0; }
   enum totalSize { NONE_totalSize = 0; }
diff --git a/Protos/SwiftProtobufTests/generated_swift_names_fields.proto b/Protos/SwiftProtobufTests/generated_swift_names_fields.proto
index 1d640b53c..fd529751f 100644
--- a/Protos/SwiftProtobufTests/generated_swift_names_fields.proto
+++ b/Protos/SwiftProtobufTests/generated_swift_names_fields.proto
@@ -281,684 +281,742 @@ message GeneratedSwiftReservedFields {
   int32 EnumValueOptions = 275;
   int32 Equatable = 276;
   int32 Error = 277;
-  int32 ExpressibleByArrayLiteral = 278;
-  int32 ExpressibleByDictionaryLiteral = 279;
-  int32 ext = 280;
-  int32 extDecoder = 281;
-  int32 extendedGraphemeClusterLiteral = 282;
-  int32 ExtendedGraphemeClusterLiteralType = 283;
-  int32 extendee = 284;
-  int32 ExtensibleMessage = 285;
-  int32 extension = 286;
-  int32 ExtensionField = 287;
-  int32 extensionFieldNumber = 288;
-  int32 ExtensionFieldValueSet = 289;
-  int32 ExtensionMap = 290;
-  int32 extensionRange = 291;
-  int32 ExtensionRangeOptions = 292;
-  int32 extensions = 293;
-  int32 extras = 294;
-  int32 F = 295;
-  int32 false = 296;
-  int32 features = 297;
-  int32 FeatureSet = 298;
-  int32 FeatureSetDefaults = 299;
-  int32 FeatureSetEditionDefault = 300;
-  int32 field = 301;
-  int32 fieldData = 302;
-  int32 FieldDescriptorProto = 303;
-  int32 FieldMask = 304;
-  int32 fieldName = 305;
-  int32 fieldNameCount = 306;
-  int32 fieldNum = 307;
-  int32 fieldNumber = 308;
-  int32 fieldNumberForProto = 309;
-  int32 FieldOptions = 310;
-  int32 fieldPresence = 311;
-  int32 fields = 312;
-  int32 fieldSize = 313;
-  int32 FieldTag = 314;
-  int32 fieldType = 315;
-  int32 file = 316;
-  int32 FileDescriptorProto = 317;
-  int32 FileDescriptorSet = 318;
-  int32 fileName = 319;
-  int32 FileOptions = 320;
-  int32 filter = 321;
-  int32 final = 322;
-  int32 first = 323;
-  int32 firstItem = 324;
-  int32 Float = 325;
-  int32 floatLiteral = 326;
-  int32 FloatLiteralType = 327;
-  int32 FloatValue = 328;
-  int32 forMessageName = 329;
-  int32 formUnion = 330;
-  int32 forReadingFrom = 331;
-  int32 forTypeURL = 332;
-  int32 ForwardParser = 333;
-  int32 forWritingInto = 334;
-  int32 from = 335;
-  int32 fromAscii2 = 336;
-  int32 fromAscii4 = 337;
-  int32 fromByteOffset = 338;
-  int32 fromHexDigit = 339;
-  int32 fullName = 340;
-  int32 func = 341;
-  int32 G = 342;
-  int32 GeneratedCodeInfo = 343;
-  int32 get = 344;
-  int32 getExtensionValue = 345;
-  int32 googleapis = 346;
-  int32 Google_Protobuf_Any = 347;
-  int32 Google_Protobuf_Api = 348;
-  int32 Google_Protobuf_BoolValue = 349;
-  int32 Google_Protobuf_BytesValue = 350;
-  int32 Google_Protobuf_DescriptorProto = 351;
-  int32 Google_Protobuf_DoubleValue = 352;
-  int32 Google_Protobuf_Duration = 353;
-  int32 Google_Protobuf_Edition = 354;
-  int32 Google_Protobuf_Empty = 355;
-  int32 Google_Protobuf_Enum = 356;
-  int32 Google_Protobuf_EnumDescriptorProto = 357;
-  int32 Google_Protobuf_EnumOptions = 358;
-  int32 Google_Protobuf_EnumValue = 359;
-  int32 Google_Protobuf_EnumValueDescriptorProto = 360;
-  int32 Google_Protobuf_EnumValueOptions = 361;
-  int32 Google_Protobuf_ExtensionRangeOptions = 362;
-  int32 Google_Protobuf_FeatureSet = 363;
-  int32 Google_Protobuf_FeatureSetDefaults = 364;
-  int32 Google_Protobuf_Field = 365;
-  int32 Google_Protobuf_FieldDescriptorProto = 366;
-  int32 Google_Protobuf_FieldMask = 367;
-  int32 Google_Protobuf_FieldOptions = 368;
-  int32 Google_Protobuf_FileDescriptorProto = 369;
-  int32 Google_Protobuf_FileDescriptorSet = 370;
-  int32 Google_Protobuf_FileOptions = 371;
-  int32 Google_Protobuf_FloatValue = 372;
-  int32 Google_Protobuf_GeneratedCodeInfo = 373;
-  int32 Google_Protobuf_Int32Value = 374;
-  int32 Google_Protobuf_Int64Value = 375;
-  int32 Google_Protobuf_ListValue = 376;
-  int32 Google_Protobuf_MessageOptions = 377;
-  int32 Google_Protobuf_Method = 378;
-  int32 Google_Protobuf_MethodDescriptorProto = 379;
-  int32 Google_Protobuf_MethodOptions = 380;
-  int32 Google_Protobuf_Mixin = 381;
-  int32 Google_Protobuf_NullValue = 382;
-  int32 Google_Protobuf_OneofDescriptorProto = 383;
-  int32 Google_Protobuf_OneofOptions = 384;
-  int32 Google_Protobuf_Option = 385;
-  int32 Google_Protobuf_ServiceDescriptorProto = 386;
-  int32 Google_Protobuf_ServiceOptions = 387;
-  int32 Google_Protobuf_SourceCodeInfo = 388;
-  int32 Google_Protobuf_SourceContext = 389;
-  int32 Google_Protobuf_StringValue = 390;
-  int32 Google_Protobuf_Struct = 391;
-  int32 Google_Protobuf_Syntax = 392;
-  int32 Google_Protobuf_Timestamp = 393;
-  int32 Google_Protobuf_Type = 394;
-  int32 Google_Protobuf_UInt32Value = 395;
-  int32 Google_Protobuf_UInt64Value = 396;
-  int32 Google_Protobuf_UninterpretedOption = 397;
-  int32 Google_Protobuf_Value = 398;
-  int32 goPackage = 399;
-  int32 group = 400;
-  int32 groupFieldNumberStack = 401;
-  int32 groupSize = 402;
-  int32 hadOneofValue = 403;
-  int32 handleConflictingOneOf = 404;
-  int32 hasAggregateValue = 405;
-  int32 hasAllowAlias = 406;
-  int32 hasBegin = 407;
-  int32 hasCcEnableArenas = 408;
-  int32 hasCcGenericServices = 409;
-  int32 hasClientStreaming = 410;
-  int32 hasCsharpNamespace = 411;
-  int32 hasCtype = 412;
-  int32 hasDebugRedact = 413;
-  int32 hasDefaultValue = 414;
-  int32 hasDeprecated = 415;
-  int32 hasDeprecatedLegacyJsonFieldConflicts = 416;
-  int32 hasDoubleValue = 417;
-  int32 hasEdition = 418;
-  int32 hasEnd = 419;
-  int32 hasEnumType = 420;
-  int32 hasExtendee = 421;
-  int32 hasExtensionValue = 422;
-  int32 hasFeatures = 423;
-  int32 hasFieldPresence = 424;
-  int32 hasFullName = 425;
-  int32 hasGoPackage = 426;
-  int32 hash = 427;
-  int32 Hashable = 428;
-  int32 hasher = 429;
-  int32 HashVisitor = 430;
-  int32 hasIdempotencyLevel = 431;
-  int32 hasIdentifierValue = 432;
-  int32 hasInputType = 433;
-  int32 hasIsExtension = 434;
-  int32 hasJavaGenerateEqualsAndHash = 435;
-  int32 hasJavaGenericServices = 436;
-  int32 hasJavaMultipleFiles = 437;
-  int32 hasJavaOuterClassname = 438;
-  int32 hasJavaPackage = 439;
-  int32 hasJavaStringCheckUtf8 = 440;
-  int32 hasJsonFormat = 441;
-  int32 hasJsonName = 442;
-  int32 hasJstype = 443;
-  int32 hasLabel = 444;
-  int32 hasLazy = 445;
-  int32 hasLeadingComments = 446;
-  int32 hasMapEntry = 447;
-  int32 hasMaximumEdition = 448;
-  int32 hasMessageEncoding = 449;
-  int32 hasMessageSetWireFormat = 450;
-  int32 hasMinimumEdition = 451;
-  int32 hasName = 452;
-  int32 hasNamePart = 453;
-  int32 hasNegativeIntValue = 454;
-  int32 hasNoStandardDescriptorAccessor = 455;
-  int32 hasNumber = 456;
-  int32 hasObjcClassPrefix = 457;
-  int32 hasOneofIndex = 458;
-  int32 hasOptimizeFor = 459;
-  int32 hasOptions = 460;
-  int32 hasOutputType = 461;
-  int32 hasPackage = 462;
-  int32 hasPacked = 463;
-  int32 hasPhpClassPrefix = 464;
-  int32 hasPhpGenericServices = 465;
-  int32 hasPhpMetadataNamespace = 466;
-  int32 hasPhpNamespace = 467;
-  int32 hasPositiveIntValue = 468;
-  int32 hasProto3Optional = 469;
-  int32 hasPyGenericServices = 470;
-  int32 hasRepeated = 471;
-  int32 hasRepeatedFieldEncoding = 472;
-  int32 hasReserved = 473;
-  int32 hasRetention = 474;
-  int32 hasRubyPackage = 475;
-  int32 hasSemantic = 476;
-  int32 hasServerStreaming = 477;
-  int32 hasSourceCodeInfo = 478;
-  int32 hasSourceContext = 479;
-  int32 hasSourceFile = 480;
-  int32 hasStart = 481;
-  int32 hasStringValue = 482;
-  int32 hasSwiftPrefix = 483;
-  int32 hasSyntax = 484;
-  int32 hasTrailingComments = 485;
-  int32 hasType = 486;
-  int32 hasTypeName = 487;
-  int32 hasUnverifiedLazy = 488;
-  int32 hasUtf8Validation = 489;
-  int32 hasValue = 490;
-  int32 hasVerification = 491;
-  int32 hasWeak = 492;
-  int32 hour = 493;
-  int32 i = 494;
-  int32 idempotencyLevel = 495;
-  int32 identifierValue = 496;
-  int32 if = 497;
-  int32 ignoreUnknownFields = 498;
-  int32 index = 499;
-  int32 init = 500;
-  int32 inout = 501;
-  int32 inputType = 502;
-  int32 insert = 503;
-  int32 Int = 504;
-  int32 Int32 = 505;
-  int32 Int32Value = 506;
-  int32 Int64 = 507;
-  int32 Int64Value = 508;
-  int32 Int8 = 509;
-  int32 integerLiteral = 510;
-  int32 IntegerLiteralType = 511;
-  int32 intern = 512;
-  int32 Internal = 513;
-  int32 InternalState = 514;
-  int32 into = 515;
-  int32 ints = 516;
-  int32 isA = 517;
-  int32 isEqual = 518;
-  int32 isEqualTo = 519;
-  int32 isExtension = 520;
-  int32 isInitialized = 521;
-  int32 isNegative = 522;
-  int32 itemTagsEncodedSize = 523;
-  int32 iterator = 524;
-  int32 javaGenerateEqualsAndHash = 525;
-  int32 javaGenericServices = 526;
-  int32 javaMultipleFiles = 527;
-  int32 javaOuterClassname = 528;
-  int32 javaPackage = 529;
-  int32 javaStringCheckUtf8 = 530;
-  int32 JSONDecoder = 531;
-  int32 JSONDecodingError = 532;
-  int32 JSONDecodingOptions = 533;
-  int32 jsonEncoder = 534;
-  int32 JSONEncodingError = 535;
-  int32 JSONEncodingOptions = 536;
-  int32 JSONEncodingVisitor = 537;
-  int32 jsonFormat = 538;
-  int32 JSONMapEncodingVisitor = 539;
-  int32 jsonName = 540;
-  int32 jsonPath = 541;
-  int32 jsonPaths = 542;
-  int32 JSONScanner = 543;
-  int32 jsonString = 544;
-  int32 jsonText = 545;
-  int32 jsonUTF8Bytes = 546;
-  int32 jsonUTF8Data = 547;
-  int32 jstype = 548;
-  int32 k = 549;
-  int32 kChunkSize = 550;
-  int32 Key = 551;
-  int32 keyField = 552;
-  int32 keyFieldOpt = 553;
-  int32 KeyType = 554;
-  int32 kind = 555;
-  int32 l = 556;
-  int32 label = 557;
-  int32 lazy = 558;
-  int32 leadingComments = 559;
-  int32 leadingDetachedComments = 560;
-  int32 length = 561;
-  int32 lessThan = 562;
-  int32 let = 563;
-  int32 lhs = 564;
-  int32 list = 565;
-  int32 listOfMessages = 566;
-  int32 listValue = 567;
-  int32 littleEndian = 568;
-  int32 littleEndianBytes = 569;
-  int32 load = 570;
-  int32 localHasher = 571;
-  int32 location = 572;
-  int32 M = 573;
-  int32 major = 574;
-  int32 makeAsyncIterator = 575;
-  int32 makeIterator = 576;
-  int32 mapEntry = 577;
-  int32 MapKeyType = 578;
-  int32 mapToMessages = 579;
-  int32 MapValueType = 580;
-  int32 mapVisitor = 581;
-  int32 maximumEdition = 582;
-  int32 mdayStart = 583;
-  int32 merge = 584;
-  int32 message = 585;
-  int32 messageDepthLimit = 586;
-  int32 messageEncoding = 587;
-  int32 MessageExtension = 588;
-  int32 MessageImplementationBase = 589;
-  int32 MessageOptions = 590;
-  int32 MessageSet = 591;
-  int32 messageSetWireFormat = 592;
-  int32 messageSize = 593;
-  int32 messageType = 594;
-  int32 Method = 595;
-  int32 MethodDescriptorProto = 596;
-  int32 MethodOptions = 597;
-  int32 methods = 598;
-  int32 min = 599;
-  int32 minimumEdition = 600;
-  int32 minor = 601;
-  int32 Mixin = 602;
-  int32 mixins = 603;
-  int32 modifier = 604;
-  int32 modify = 605;
-  int32 month = 606;
-  int32 msgExtension = 607;
-  int32 mutating = 608;
-  int32 n = 609;
-  int32 name = 610;
-  int32 NameDescription = 611;
-  int32 NameMap = 612;
-  int32 NamePart = 613;
-  int32 names = 614;
-  int32 nanos = 615;
-  int32 negativeIntValue = 616;
-  int32 nestedType = 617;
-  int32 newL = 618;
-  int32 newList = 619;
-  int32 newValue = 620;
-  int32 next = 621;
-  int32 nextByte = 622;
-  int32 nextFieldNumber = 623;
-  int32 nextVarInt = 624;
-  int32 nil = 625;
-  int32 nilLiteral = 626;
-  int32 noStandardDescriptorAccessor = 627;
-  int32 nullValue = 628;
-  int32 number = 629;
-  int32 numberValue = 630;
-  int32 objcClassPrefix = 631;
-  int32 of = 632;
-  int32 oneofDecl = 633;
-  int32 OneofDescriptorProto = 634;
-  int32 oneofIndex = 635;
-  int32 OneofOptions = 636;
-  int32 oneofs = 637;
-  int32 OneOf_Kind = 638;
-  int32 optimizeFor = 639;
-  int32 OptimizeMode = 640;
-  int32 Option = 641;
-  int32 OptionalEnumExtensionField = 642;
-  int32 OptionalExtensionField = 643;
-  int32 OptionalGroupExtensionField = 644;
-  int32 OptionalMessageExtensionField = 645;
-  int32 OptionRetention = 646;
-  int32 options = 647;
-  int32 OptionTargetType = 648;
-  int32 other = 649;
-  int32 others = 650;
-  int32 out = 651;
-  int32 outputType = 652;
-  int32 p = 653;
-  int32 package = 654;
-  int32 packed = 655;
-  int32 PackedEnumExtensionField = 656;
-  int32 PackedExtensionField = 657;
-  int32 padding = 658;
-  int32 parent = 659;
-  int32 parse = 660;
-  int32 path = 661;
-  int32 paths = 662;
-  int32 payload = 663;
-  int32 payloadSize = 664;
-  int32 phpClassPrefix = 665;
-  int32 phpGenericServices = 666;
-  int32 phpMetadataNamespace = 667;
-  int32 phpNamespace = 668;
-  int32 pos = 669;
-  int32 positiveIntValue = 670;
-  int32 prefix = 671;
-  int32 preserveProtoFieldNames = 672;
-  int32 preTraverse = 673;
-  int32 printUnknownFields = 674;
-  int32 proto2 = 675;
-  int32 proto3DefaultValue = 676;
-  int32 proto3Optional = 677;
-  int32 ProtobufAPIVersionCheck = 678;
-  int32 ProtobufAPIVersion_3 = 679;
-  int32 ProtobufBool = 680;
-  int32 ProtobufBytes = 681;
-  int32 ProtobufDouble = 682;
-  int32 ProtobufEnumMap = 683;
-  int32 protobufExtension = 684;
-  int32 ProtobufFixed32 = 685;
-  int32 ProtobufFixed64 = 686;
-  int32 ProtobufFloat = 687;
-  int32 ProtobufInt32 = 688;
-  int32 ProtobufInt64 = 689;
-  int32 ProtobufMap = 690;
-  int32 ProtobufMessageMap = 691;
-  int32 ProtobufSFixed32 = 692;
-  int32 ProtobufSFixed64 = 693;
-  int32 ProtobufSInt32 = 694;
-  int32 ProtobufSInt64 = 695;
-  int32 ProtobufString = 696;
-  int32 ProtobufUInt32 = 697;
-  int32 ProtobufUInt64 = 698;
-  int32 protobuf_extensionFieldValues = 699;
-  int32 protobuf_fieldNumber = 700;
-  int32 protobuf_generated_isEqualTo = 701;
-  int32 protobuf_nameMap = 702;
-  int32 protobuf_newField = 703;
-  int32 protobuf_package = 704;
-  int32 protocol = 705;
-  int32 protoFieldName = 706;
-  int32 protoMessageName = 707;
-  int32 ProtoNameProviding = 708;
-  int32 protoPaths = 709;
-  int32 public = 710;
-  int32 publicDependency = 711;
-  int32 putBoolValue = 712;
-  int32 putBytesValue = 713;
-  int32 putDoubleValue = 714;
-  int32 putEnumValue = 715;
-  int32 putFixedUInt32 = 716;
-  int32 putFixedUInt64 = 717;
-  int32 putFloatValue = 718;
-  int32 putInt64 = 719;
-  int32 putStringValue = 720;
-  int32 putUInt64 = 721;
-  int32 putUInt64Hex = 722;
-  int32 putVarInt = 723;
-  int32 putZigZagVarInt = 724;
-  int32 pyGenericServices = 725;
-  int32 R = 726;
-  int32 rawChars = 727;
-  int32 RawRepresentable = 728;
-  int32 RawValue = 729;
-  int32 read4HexDigits = 730;
-  int32 readBytes = 731;
-  int32 register = 732;
-  int32 repeated = 733;
-  int32 RepeatedEnumExtensionField = 734;
-  int32 RepeatedExtensionField = 735;
-  int32 repeatedFieldEncoding = 736;
-  int32 RepeatedGroupExtensionField = 737;
-  int32 RepeatedMessageExtensionField = 738;
-  int32 repeating = 739;
-  int32 requestStreaming = 740;
-  int32 requestTypeURL = 741;
-  int32 requiredSize = 742;
-  int32 responseStreaming = 743;
-  int32 responseTypeURL = 744;
-  int32 result = 745;
-  int32 retention = 746;
-  int32 rethrows = 747;
-  int32 return = 748;
-  int32 ReturnType = 749;
-  int32 revision = 750;
-  int32 rhs = 751;
-  int32 root = 752;
-  int32 rubyPackage = 753;
-  int32 s = 754;
-  int32 sawBackslash = 755;
-  int32 sawSection4Characters = 756;
-  int32 sawSection5Characters = 757;
-  int32 scanner = 758;
-  int32 seconds = 759;
-  int32 self = 760;
-  int32 semantic = 761;
-  int32 Sendable = 762;
-  int32 separator = 763;
-  int32 serialize = 764;
-  int32 serializedBytes = 765;
-  int32 serializedData = 766;
-  int32 serializedSize = 767;
-  int32 serverStreaming = 768;
-  int32 service = 769;
-  int32 ServiceDescriptorProto = 770;
-  int32 ServiceOptions = 771;
-  int32 set = 772;
-  int32 setExtensionValue = 773;
-  int32 shift = 774;
-  int32 SimpleExtensionMap = 775;
-  int32 size = 776;
-  int32 sizer = 777;
-  int32 source = 778;
-  int32 sourceCodeInfo = 779;
-  int32 sourceContext = 780;
-  int32 sourceEncoding = 781;
-  int32 sourceFile = 782;
-  int32 span = 783;
-  int32 split = 784;
-  int32 start = 785;
-  int32 startArray = 786;
-  int32 startArrayObject = 787;
-  int32 startField = 788;
-  int32 startIndex = 789;
-  int32 startMessageField = 790;
-  int32 startObject = 791;
-  int32 startRegularField = 792;
-  int32 state = 793;
-  int32 static = 794;
-  int32 StaticString = 795;
-  int32 storage = 796;
-  int32 String = 797;
-  int32 stringLiteral = 798;
-  int32 StringLiteralType = 799;
-  int32 stringResult = 800;
-  int32 stringValue = 801;
-  int32 struct = 802;
-  int32 structValue = 803;
-  int32 subDecoder = 804;
-  int32 subscript = 805;
-  int32 subVisitor = 806;
-  int32 Swift = 807;
-  int32 swiftPrefix = 808;
-  int32 SwiftProtobufContiguousBytes = 809;
-  int32 syntax = 810;
-  int32 T = 811;
-  int32 tag = 812;
-  int32 targets = 813;
-  int32 terminator = 814;
-  int32 testDecoder = 815;
-  int32 text = 816;
-  int32 textDecoder = 817;
-  int32 TextFormatDecoder = 818;
-  int32 TextFormatDecodingError = 819;
-  int32 TextFormatDecodingOptions = 820;
-  int32 TextFormatEncodingOptions = 821;
-  int32 TextFormatEncodingVisitor = 822;
-  int32 textFormatString = 823;
-  int32 throwOrIgnore = 824;
-  int32 throws = 825;
-  int32 timeInterval = 826;
-  int32 timeIntervalSince1970 = 827;
-  int32 timeIntervalSinceReferenceDate = 828;
-  int32 Timestamp = 829;
-  int32 total = 830;
-  int32 totalArrayDepth = 831;
-  int32 totalSize = 832;
-  int32 trailingComments = 833;
-  int32 traverse = 834;
-  int32 true = 835;
-  int32 try = 836;
-  int32 type = 837;
-  int32 typealias = 838;
-  int32 TypeEnum = 839;
-  int32 typeName = 840;
-  int32 typePrefix = 841;
-  int32 typeStart = 842;
-  int32 typeUnknown = 843;
-  int32 typeURL = 844;
-  int32 UInt32 = 845;
-  int32 UInt32Value = 846;
-  int32 UInt64 = 847;
-  int32 UInt64Value = 848;
-  int32 UInt8 = 849;
-  int32 unchecked = 850;
-  int32 unicodeScalarLiteral = 851;
-  int32 UnicodeScalarLiteralType = 852;
-  int32 unicodeScalars = 853;
-  int32 UnicodeScalarView = 854;
-  int32 uninterpretedOption = 855;
-  int32 union = 856;
-  int32 uniqueStorage = 857;
-  int32 unknown = 858;
-  int32 unknownFields = 859;
-  int32 UnknownStorage = 860;
-  int32 unpackTo = 861;
-  int32 UnsafeBufferPointer = 862;
-  int32 UnsafeMutablePointer = 863;
-  int32 UnsafeMutableRawBufferPointer = 864;
-  int32 UnsafeRawBufferPointer = 865;
-  int32 UnsafeRawPointer = 866;
-  int32 unverifiedLazy = 867;
-  int32 updatedOptions = 868;
-  int32 url = 869;
-  int32 useDeterministicOrdering = 870;
-  int32 utf8 = 871;
-  int32 utf8Ptr = 872;
-  int32 utf8ToDouble = 873;
-  int32 utf8Validation = 874;
-  int32 UTF8View = 875;
-  int32 v = 876;
-  int32 value = 877;
-  int32 valueField = 878;
-  int32 values = 879;
-  int32 ValueType = 880;
-  int32 var = 881;
-  int32 verification = 882;
-  int32 VerificationState = 883;
-  int32 Version = 884;
-  int32 versionString = 885;
-  int32 visitExtensionFields = 886;
-  int32 visitExtensionFieldsAsMessageSet = 887;
-  int32 visitMapField = 888;
-  int32 visitor = 889;
-  int32 visitPacked = 890;
-  int32 visitPackedBoolField = 891;
-  int32 visitPackedDoubleField = 892;
-  int32 visitPackedEnumField = 893;
-  int32 visitPackedFixed32Field = 894;
-  int32 visitPackedFixed64Field = 895;
-  int32 visitPackedFloatField = 896;
-  int32 visitPackedInt32Field = 897;
-  int32 visitPackedInt64Field = 898;
-  int32 visitPackedSFixed32Field = 899;
-  int32 visitPackedSFixed64Field = 900;
-  int32 visitPackedSInt32Field = 901;
-  int32 visitPackedSInt64Field = 902;
-  int32 visitPackedUInt32Field = 903;
-  int32 visitPackedUInt64Field = 904;
-  int32 visitRepeated = 905;
-  int32 visitRepeatedBoolField = 906;
-  int32 visitRepeatedBytesField = 907;
-  int32 visitRepeatedDoubleField = 908;
-  int32 visitRepeatedEnumField = 909;
-  int32 visitRepeatedFixed32Field = 910;
-  int32 visitRepeatedFixed64Field = 911;
-  int32 visitRepeatedFloatField = 912;
-  int32 visitRepeatedGroupField = 913;
-  int32 visitRepeatedInt32Field = 914;
-  int32 visitRepeatedInt64Field = 915;
-  int32 visitRepeatedMessageField = 916;
-  int32 visitRepeatedSFixed32Field = 917;
-  int32 visitRepeatedSFixed64Field = 918;
-  int32 visitRepeatedSInt32Field = 919;
-  int32 visitRepeatedSInt64Field = 920;
-  int32 visitRepeatedStringField = 921;
-  int32 visitRepeatedUInt32Field = 922;
-  int32 visitRepeatedUInt64Field = 923;
-  int32 visitSingular = 924;
-  int32 visitSingularBoolField = 925;
-  int32 visitSingularBytesField = 926;
-  int32 visitSingularDoubleField = 927;
-  int32 visitSingularEnumField = 928;
-  int32 visitSingularFixed32Field = 929;
-  int32 visitSingularFixed64Field = 930;
-  int32 visitSingularFloatField = 931;
-  int32 visitSingularGroupField = 932;
-  int32 visitSingularInt32Field = 933;
-  int32 visitSingularInt64Field = 934;
-  int32 visitSingularMessageField = 935;
-  int32 visitSingularSFixed32Field = 936;
-  int32 visitSingularSFixed64Field = 937;
-  int32 visitSingularSInt32Field = 938;
-  int32 visitSingularSInt64Field = 939;
-  int32 visitSingularStringField = 940;
-  int32 visitSingularUInt32Field = 941;
-  int32 visitSingularUInt64Field = 942;
-  int32 visitUnknown = 943;
-  int32 wasDecoded = 944;
-  int32 weak = 945;
-  int32 weakDependency = 946;
-  int32 where = 947;
-  int32 wireFormat = 948;
-  int32 with = 949;
-  int32 withUnsafeBytes = 950;
-  int32 withUnsafeMutableBytes = 951;
-  int32 work = 952;
-  int32 Wrapped = 953;
-  int32 WrappedType = 954;
-  int32 wrappedValue = 955;
-  int32 written = 956;
-  int32 yday = 957;
+  int32 escaping = 278;
+  int32 ExpressibleByArrayLiteral = 279;
+  int32 ExpressibleByDictionaryLiteral = 280;
+  int32 ext = 281;
+  int32 extDecoder = 282;
+  int32 extendedGraphemeClusterLiteral = 283;
+  int32 ExtendedGraphemeClusterLiteralType = 284;
+  int32 extendee = 285;
+  int32 ExtensibleMessage = 286;
+  int32 extension = 287;
+  int32 ExtensionField = 288;
+  int32 extensionFieldNumber = 289;
+  int32 extensionFields = 290;
+  int32 extensionFieldsAsMessageSet = 291;
+  int32 ExtensionFieldValueSet = 292;
+  int32 ExtensionMap = 293;
+  int32 extensionRange = 294;
+  int32 ExtensionRangeOptions = 295;
+  int32 extensions = 296;
+  int32 extras = 297;
+  int32 F = 298;
+  int32 false = 299;
+  int32 features = 300;
+  int32 FeatureSet = 301;
+  int32 FeatureSetDefaults = 302;
+  int32 FeatureSetEditionDefault = 303;
+  int32 field = 304;
+  int32 fieldData = 305;
+  int32 FieldDescriptorProto = 306;
+  int32 FieldMask = 307;
+  int32 fieldName = 308;
+  int32 fieldNameCount = 309;
+  int32 fieldNum = 310;
+  int32 fieldNumber = 311;
+  int32 fieldNumberForProto = 312;
+  int32 FieldOptions = 313;
+  int32 fieldPresence = 314;
+  int32 fields = 315;
+  int32 fieldSize = 316;
+  int32 FieldTag = 317;
+  int32 fieldType = 318;
+  int32 file = 319;
+  int32 FileDescriptorProto = 320;
+  int32 FileDescriptorSet = 321;
+  int32 fileName = 322;
+  int32 FileOptions = 323;
+  int32 filter = 324;
+  int32 final = 325;
+  int32 first = 326;
+  int32 firstItem = 327;
+  int32 Float = 328;
+  int32 floatLiteral = 329;
+  int32 FloatLiteralType = 330;
+  int32 FloatValue = 331;
+  int32 forMessageName = 332;
+  int32 formUnion = 333;
+  int32 forReadingFrom = 334;
+  int32 forTypeURL = 335;
+  int32 ForwardParser = 336;
+  int32 forWritingInto = 337;
+  int32 from = 338;
+  int32 fromAscii2 = 339;
+  int32 fromAscii4 = 340;
+  int32 fromByteOffset = 341;
+  int32 fromHexDigit = 342;
+  int32 fullName = 343;
+  int32 func = 344;
+  int32 G = 345;
+  int32 GeneratedCodeInfo = 346;
+  int32 get = 347;
+  int32 getExtensionValue = 348;
+  int32 getValue = 349;
+  int32 googleapis = 350;
+  int32 Google_Protobuf_Any = 351;
+  int32 Google_Protobuf_Api = 352;
+  int32 Google_Protobuf_BoolValue = 353;
+  int32 Google_Protobuf_BytesValue = 354;
+  int32 Google_Protobuf_DescriptorProto = 355;
+  int32 Google_Protobuf_DoubleValue = 356;
+  int32 Google_Protobuf_Duration = 357;
+  int32 Google_Protobuf_Edition = 358;
+  int32 Google_Protobuf_Empty = 359;
+  int32 Google_Protobuf_Enum = 360;
+  int32 Google_Protobuf_EnumDescriptorProto = 361;
+  int32 Google_Protobuf_EnumOptions = 362;
+  int32 Google_Protobuf_EnumValue = 363;
+  int32 Google_Protobuf_EnumValueDescriptorProto = 364;
+  int32 Google_Protobuf_EnumValueOptions = 365;
+  int32 Google_Protobuf_ExtensionRangeOptions = 366;
+  int32 Google_Protobuf_FeatureSet = 367;
+  int32 Google_Protobuf_FeatureSetDefaults = 368;
+  int32 Google_Protobuf_Field = 369;
+  int32 Google_Protobuf_FieldDescriptorProto = 370;
+  int32 Google_Protobuf_FieldMask = 371;
+  int32 Google_Protobuf_FieldOptions = 372;
+  int32 Google_Protobuf_FileDescriptorProto = 373;
+  int32 Google_Protobuf_FileDescriptorSet = 374;
+  int32 Google_Protobuf_FileOptions = 375;
+  int32 Google_Protobuf_FloatValue = 376;
+  int32 Google_Protobuf_GeneratedCodeInfo = 377;
+  int32 Google_Protobuf_Int32Value = 378;
+  int32 Google_Protobuf_Int64Value = 379;
+  int32 Google_Protobuf_ListValue = 380;
+  int32 Google_Protobuf_MessageOptions = 381;
+  int32 Google_Protobuf_Method = 382;
+  int32 Google_Protobuf_MethodDescriptorProto = 383;
+  int32 Google_Protobuf_MethodOptions = 384;
+  int32 Google_Protobuf_Mixin = 385;
+  int32 Google_Protobuf_NullValue = 386;
+  int32 Google_Protobuf_OneofDescriptorProto = 387;
+  int32 Google_Protobuf_OneofOptions = 388;
+  int32 Google_Protobuf_Option = 389;
+  int32 Google_Protobuf_ServiceDescriptorProto = 390;
+  int32 Google_Protobuf_ServiceOptions = 391;
+  int32 Google_Protobuf_SourceCodeInfo = 392;
+  int32 Google_Protobuf_SourceContext = 393;
+  int32 Google_Protobuf_StringValue = 394;
+  int32 Google_Protobuf_Struct = 395;
+  int32 Google_Protobuf_Syntax = 396;
+  int32 Google_Protobuf_Timestamp = 397;
+  int32 Google_Protobuf_Type = 398;
+  int32 Google_Protobuf_UInt32Value = 399;
+  int32 Google_Protobuf_UInt64Value = 400;
+  int32 Google_Protobuf_UninterpretedOption = 401;
+  int32 Google_Protobuf_Value = 402;
+  int32 goPackage = 403;
+  int32 group = 404;
+  int32 groupFieldNumberStack = 405;
+  int32 groupSize = 406;
+  int32 hadOneofValue = 407;
+  int32 handleConflictingOneOf = 408;
+  int32 hasAggregateValue = 409;
+  int32 hasAllowAlias = 410;
+  int32 hasBegin = 411;
+  int32 hasCcEnableArenas = 412;
+  int32 hasCcGenericServices = 413;
+  int32 hasClientStreaming = 414;
+  int32 hasCsharpNamespace = 415;
+  int32 hasCtype = 416;
+  int32 hasDebugRedact = 417;
+  int32 hasDefaultValue = 418;
+  int32 hasDeprecated = 419;
+  int32 hasDeprecatedLegacyJsonFieldConflicts = 420;
+  int32 hasDoubleValue = 421;
+  int32 hasEdition = 422;
+  int32 hasEnd = 423;
+  int32 hasEnumType = 424;
+  int32 hasExtendee = 425;
+  int32 hasExtensionValue = 426;
+  int32 hasFeatures = 427;
+  int32 hasFieldPresence = 428;
+  int32 hasFullName = 429;
+  int32 hasGoPackage = 430;
+  int32 hash = 431;
+  int32 Hashable = 432;
+  int32 hasher = 433;
+  int32 HashVisitor = 434;
+  int32 hasIdempotencyLevel = 435;
+  int32 hasIdentifierValue = 436;
+  int32 hasInputType = 437;
+  int32 hasIsExtension = 438;
+  int32 hasJavaGenerateEqualsAndHash = 439;
+  int32 hasJavaGenericServices = 440;
+  int32 hasJavaMultipleFiles = 441;
+  int32 hasJavaOuterClassname = 442;
+  int32 hasJavaPackage = 443;
+  int32 hasJavaStringCheckUtf8 = 444;
+  int32 hasJsonFormat = 445;
+  int32 hasJsonName = 446;
+  int32 hasJstype = 447;
+  int32 hasLabel = 448;
+  int32 hasLazy = 449;
+  int32 hasLeadingComments = 450;
+  int32 hasMapEntry = 451;
+  int32 hasMaximumEdition = 452;
+  int32 hasMessageEncoding = 453;
+  int32 hasMessageSetWireFormat = 454;
+  int32 hasMinimumEdition = 455;
+  int32 hasName = 456;
+  int32 hasNamePart = 457;
+  int32 hasNegativeIntValue = 458;
+  int32 hasNoStandardDescriptorAccessor = 459;
+  int32 hasNumber = 460;
+  int32 hasObjcClassPrefix = 461;
+  int32 hasOneofIndex = 462;
+  int32 hasOptimizeFor = 463;
+  int32 hasOptions = 464;
+  int32 hasOutputType = 465;
+  int32 hasPackage = 466;
+  int32 hasPacked = 467;
+  int32 hasPhpClassPrefix = 468;
+  int32 hasPhpGenericServices = 469;
+  int32 hasPhpMetadataNamespace = 470;
+  int32 hasPhpNamespace = 471;
+  int32 hasPositiveIntValue = 472;
+  int32 hasProto3Optional = 473;
+  int32 hasPyGenericServices = 474;
+  int32 hasRepeated = 475;
+  int32 hasRepeatedFieldEncoding = 476;
+  int32 hasReserved = 477;
+  int32 hasRetention = 478;
+  int32 hasRubyPackage = 479;
+  int32 hasSemantic = 480;
+  int32 hasServerStreaming = 481;
+  int32 hasSourceCodeInfo = 482;
+  int32 hasSourceContext = 483;
+  int32 hasSourceFile = 484;
+  int32 hasStart = 485;
+  int32 hasStringValue = 486;
+  int32 hasSwiftPrefix = 487;
+  int32 hasSyntax = 488;
+  int32 hasTrailingComments = 489;
+  int32 hasType = 490;
+  int32 hasTypeName = 491;
+  int32 hasUnverifiedLazy = 492;
+  int32 hasUtf8Validation = 493;
+  int32 hasValue = 494;
+  int32 hasVerification = 495;
+  int32 hasWeak = 496;
+  int32 hour = 497;
+  int32 i = 498;
+  int32 idempotencyLevel = 499;
+  int32 identifierValue = 500;
+  int32 if = 501;
+  int32 ignoreUnknownFields = 502;
+  int32 index = 503;
+  int32 init = 504;
+  int32 inout = 505;
+  int32 inputType = 506;
+  int32 insert = 507;
+  int32 Int = 508;
+  int32 Int32 = 509;
+  int32 Int32Value = 510;
+  int32 Int64 = 511;
+  int32 Int64Value = 512;
+  int32 Int8 = 513;
+  int32 integerLiteral = 514;
+  int32 IntegerLiteralType = 515;
+  int32 intern = 516;
+  int32 Internal = 517;
+  int32 InternalState = 518;
+  int32 into = 519;
+  int32 ints = 520;
+  int32 isA = 521;
+  int32 isEqual = 522;
+  int32 isEqualTo = 523;
+  int32 isExtension = 524;
+  int32 isInitialized = 525;
+  int32 isNegative = 526;
+  int32 isUnset = 527;
+  int32 itemTagsEncodedSize = 528;
+  int32 iterator = 529;
+  int32 javaGenerateEqualsAndHash = 530;
+  int32 javaGenericServices = 531;
+  int32 javaMultipleFiles = 532;
+  int32 javaOuterClassname = 533;
+  int32 javaPackage = 534;
+  int32 javaStringCheckUtf8 = 535;
+  int32 JSONDecoder = 536;
+  int32 JSONDecodingError = 537;
+  int32 JSONDecodingOptions = 538;
+  int32 jsonEncoder = 539;
+  int32 JSONEncodingError = 540;
+  int32 JSONEncodingOptions = 541;
+  int32 JSONEncodingVisitor = 542;
+  int32 jsonFormat = 543;
+  int32 JSONMapEncodingVisitor = 544;
+  int32 jsonName = 545;
+  int32 jsonPath = 546;
+  int32 jsonPaths = 547;
+  int32 JSONScanner = 548;
+  int32 jsonString = 549;
+  int32 jsonText = 550;
+  int32 jsonUTF8Bytes = 551;
+  int32 jsonUTF8Data = 552;
+  int32 jstype = 553;
+  int32 k = 554;
+  int32 kChunkSize = 555;
+  int32 Key = 556;
+  int32 keyField = 557;
+  int32 keyFieldOpt = 558;
+  int32 KeyType = 559;
+  int32 kind = 560;
+  int32 l = 561;
+  int32 label = 562;
+  int32 lazy = 563;
+  int32 leadingComments = 564;
+  int32 leadingDetachedComments = 565;
+  int32 length = 566;
+  int32 lessThan = 567;
+  int32 let = 568;
+  int32 lhs = 569;
+  int32 list = 570;
+  int32 listOfMessages = 571;
+  int32 listValue = 572;
+  int32 littleEndian = 573;
+  int32 littleEndianBytes = 574;
+  int32 load = 575;
+  int32 localHasher = 576;
+  int32 location = 577;
+  int32 M = 578;
+  int32 major = 579;
+  int32 makeAsyncIterator = 580;
+  int32 makeIterator = 581;
+  int32 map = 582;
+  int32 mapEntry = 583;
+  int32 MapKeyType = 584;
+  int32 mapToMessages = 585;
+  int32 MapValueType = 586;
+  int32 mapVisitor = 587;
+  int32 maximumEdition = 588;
+  int32 mdayStart = 589;
+  int32 merge = 590;
+  int32 message = 591;
+  int32 messageDepthLimit = 592;
+  int32 messageEncoding = 593;
+  int32 MessageExtension = 594;
+  int32 MessageImplementationBase = 595;
+  int32 MessageOptions = 596;
+  int32 MessageSet = 597;
+  int32 messageSetWireFormat = 598;
+  int32 messageSize = 599;
+  int32 messageType = 600;
+  int32 Method = 601;
+  int32 MethodDescriptorProto = 602;
+  int32 MethodOptions = 603;
+  int32 methods = 604;
+  int32 min = 605;
+  int32 minimumEdition = 606;
+  int32 minor = 607;
+  int32 Mixin = 608;
+  int32 mixins = 609;
+  int32 modifier = 610;
+  int32 modify = 611;
+  int32 month = 612;
+  int32 msgExtension = 613;
+  int32 mutating = 614;
+  int32 n = 615;
+  int32 name = 616;
+  int32 NameDescription = 617;
+  int32 NameMap = 618;
+  int32 NamePart = 619;
+  int32 names = 620;
+  int32 nanos = 621;
+  int32 negativeIntValue = 622;
+  int32 nestedType = 623;
+  int32 newL = 624;
+  int32 newList = 625;
+  int32 newValue = 626;
+  int32 next = 627;
+  int32 nextByte = 628;
+  int32 nextFieldNumber = 629;
+  int32 nextVarInt = 630;
+  int32 nil = 631;
+  int32 nilLiteral = 632;
+  int32 noStandardDescriptorAccessor = 633;
+  int32 nullValue = 634;
+  int32 number = 635;
+  int32 numberValue = 636;
+  int32 objcClassPrefix = 637;
+  int32 of = 638;
+  int32 oneOf = 639;
+  int32 oneofDecl = 640;
+  int32 OneofDescriptorProto = 641;
+  int32 oneofIndex = 642;
+  int32 OneofOptions = 643;
+  int32 oneofs = 644;
+  int32 OneOf_Kind = 645;
+  int32 optimizeFor = 646;
+  int32 OptimizeMode = 647;
+  int32 Option = 648;
+  int32 OptionalEnumExtensionField = 649;
+  int32 OptionalExtensionField = 650;
+  int32 OptionalGroupExtensionField = 651;
+  int32 OptionalMessageExtensionField = 652;
+  int32 OptionRetention = 653;
+  int32 options = 654;
+  int32 OptionTargetType = 655;
+  int32 other = 656;
+  int32 others = 657;
+  int32 out = 658;
+  int32 outputType = 659;
+  int32 p = 660;
+  int32 package = 661;
+  int32 packed = 662;
+  int32 packedBool = 663;
+  int32 packedDouble = 664;
+  int32 packedEnum = 665;
+  int32 PackedEnumExtensionField = 666;
+  int32 PackedExtensionField = 667;
+  int32 packedFixed32 = 668;
+  int32 packedFixed64 = 669;
+  int32 packedFloat = 670;
+  int32 packedInt32 = 671;
+  int32 packedInt64 = 672;
+  int32 packedSFixed32 = 673;
+  int32 packedSFixed64 = 674;
+  int32 packedSInt32 = 675;
+  int32 packedSInt64 = 676;
+  int32 packedUInt32 = 677;
+  int32 packedUInt64 = 678;
+  int32 padding = 679;
+  int32 parent = 680;
+  int32 parse = 681;
+  int32 path = 682;
+  int32 paths = 683;
+  int32 payload = 684;
+  int32 payloadSize = 685;
+  int32 phpClassPrefix = 686;
+  int32 phpGenericServices = 687;
+  int32 phpMetadataNamespace = 688;
+  int32 phpNamespace = 689;
+  int32 pos = 690;
+  int32 positiveIntValue = 691;
+  int32 prefix = 692;
+  int32 preserveProtoFieldNames = 693;
+  int32 preTraverse = 694;
+  int32 printUnknownFields = 695;
+  int32 proto2 = 696;
+  int32 proto3DefaultValue = 697;
+  int32 proto3Optional = 698;
+  int32 ProtobufAPIVersionCheck = 699;
+  int32 ProtobufAPIVersion_3 = 700;
+  int32 ProtobufBool = 701;
+  int32 ProtobufBytes = 702;
+  int32 ProtobufDouble = 703;
+  int32 ProtobufEnumMap = 704;
+  int32 protobufExtension = 705;
+  int32 ProtobufFixed32 = 706;
+  int32 ProtobufFixed64 = 707;
+  int32 ProtobufFloat = 708;
+  int32 ProtobufInt32 = 709;
+  int32 ProtobufInt64 = 710;
+  int32 ProtobufMap = 711;
+  int32 ProtobufMessageMap = 712;
+  int32 ProtobufSFixed32 = 713;
+  int32 ProtobufSFixed64 = 714;
+  int32 ProtobufSInt32 = 715;
+  int32 ProtobufSInt64 = 716;
+  int32 ProtobufString = 717;
+  int32 ProtobufUInt32 = 718;
+  int32 ProtobufUInt64 = 719;
+  int32 protobuf_extensionFieldValues = 720;
+  int32 protobuf_fieldNumber = 721;
+  int32 protobuf_generated_isEqualTo = 722;
+  int32 protobuf_nameMap = 723;
+  int32 protobuf_newField = 724;
+  int32 protobuf_package = 725;
+  int32 protocol = 726;
+  int32 protoFieldName = 727;
+  int32 protoMessageName = 728;
+  int32 ProtoNameProviding = 729;
+  int32 protoPaths = 730;
+  int32 public = 731;
+  int32 publicDependency = 732;
+  int32 putBoolValue = 733;
+  int32 putBytesValue = 734;
+  int32 putDoubleValue = 735;
+  int32 putEnumValue = 736;
+  int32 putFixedUInt32 = 737;
+  int32 putFixedUInt64 = 738;
+  int32 putFloatValue = 739;
+  int32 putInt64 = 740;
+  int32 putStringValue = 741;
+  int32 putUInt64 = 742;
+  int32 putUInt64Hex = 743;
+  int32 putVarInt = 744;
+  int32 putZigZagVarInt = 745;
+  int32 pyGenericServices = 746;
+  int32 R = 747;
+  int32 rawChars = 748;
+  int32 RawRepresentable = 749;
+  int32 RawValue = 750;
+  int32 read4HexDigits = 751;
+  int32 readBytes = 752;
+  int32 register = 753;
+  int32 repeated = 754;
+  int32 repeatedBool = 755;
+  int32 repeatedBytes = 756;
+  int32 repeatedDouble = 757;
+  int32 repeatedEnum = 758;
+  int32 RepeatedEnumExtensionField = 759;
+  int32 RepeatedExtensionField = 760;
+  int32 repeatedFieldEncoding = 761;
+  int32 repeatedFixed32 = 762;
+  int32 repeatedFixed64 = 763;
+  int32 repeatedFloat = 764;
+  int32 repeatedGroup = 765;
+  int32 RepeatedGroupExtensionField = 766;
+  int32 repeatedInt32 = 767;
+  int32 repeatedInt64 = 768;
+  int32 repeatedMessage = 769;
+  int32 RepeatedMessageExtensionField = 770;
+  int32 repeatedSFixed32 = 771;
+  int32 repeatedSFixed64 = 772;
+  int32 repeatedSInt32 = 773;
+  int32 repeatedSInt64 = 774;
+  int32 repeatedString = 775;
+  int32 repeatedUInt32 = 776;
+  int32 repeatedUInt64 = 777;
+  int32 repeating = 778;
+  int32 requestStreaming = 779;
+  int32 requestTypeURL = 780;
+  int32 requiredSize = 781;
+  int32 responseStreaming = 782;
+  int32 responseTypeURL = 783;
+  int32 result = 784;
+  int32 retention = 785;
+  int32 rethrows = 786;
+  int32 return = 787;
+  int32 ReturnType = 788;
+  int32 revision = 789;
+  int32 rhs = 790;
+  int32 root = 791;
+  int32 rubyPackage = 792;
+  int32 s = 793;
+  int32 sawBackslash = 794;
+  int32 sawSection4Characters = 795;
+  int32 sawSection5Characters = 796;
+  int32 scanner = 797;
+  int32 seconds = 798;
+  int32 self = 799;
+  int32 semantic = 800;
+  int32 Sendable = 801;
+  int32 separator = 802;
+  int32 serialize = 803;
+  int32 serializedBytes = 804;
+  int32 serializedData = 805;
+  int32 serializedSize = 806;
+  int32 serverStreaming = 807;
+  int32 service = 808;
+  int32 ServiceDescriptorProto = 809;
+  int32 ServiceOptions = 810;
+  int32 set = 811;
+  int32 setExtensionValue = 812;
+  int32 shift = 813;
+  int32 SimpleExtensionMap = 814;
+  int32 singularBool = 815;
+  int32 singularBytes = 816;
+  int32 singularDouble = 817;
+  int32 singularEnum = 818;
+  int32 singularFixed32 = 819;
+  int32 singularFixed64 = 820;
+  int32 singularFloat = 821;
+  int32 singularGroup = 822;
+  int32 singularInt32 = 823;
+  int32 singularInt64 = 824;
+  int32 singularMessage = 825;
+  int32 singularSFixed32 = 826;
+  int32 singularSFixed64 = 827;
+  int32 singularSInt32 = 828;
+  int32 singularSInt64 = 829;
+  int32 singularString = 830;
+  int32 singularUInt32 = 831;
+  int32 singularUInt64 = 832;
+  int32 size = 833;
+  int32 sizer = 834;
+  int32 source = 835;
+  int32 sourceCodeInfo = 836;
+  int32 sourceContext = 837;
+  int32 sourceEncoding = 838;
+  int32 sourceFile = 839;
+  int32 span = 840;
+  int32 split = 841;
+  int32 start = 842;
+  int32 startArray = 843;
+  int32 startArrayObject = 844;
+  int32 startField = 845;
+  int32 startIndex = 846;
+  int32 startMessageField = 847;
+  int32 startObject = 848;
+  int32 startRegularField = 849;
+  int32 state = 850;
+  int32 static = 851;
+  int32 StaticString = 852;
+  int32 storage = 853;
+  int32 String = 854;
+  int32 stringLiteral = 855;
+  int32 StringLiteralType = 856;
+  int32 stringResult = 857;
+  int32 stringValue = 858;
+  int32 struct = 859;
+  int32 structValue = 860;
+  int32 subDecoder = 861;
+  int32 subscript = 862;
+  int32 subVisitor = 863;
+  int32 Swift = 864;
+  int32 swiftPrefix = 865;
+  int32 SwiftProtobufContiguousBytes = 866;
+  int32 syntax = 867;
+  int32 T = 868;
+  int32 tag = 869;
+  int32 targets = 870;
+  int32 terminator = 871;
+  int32 testDecoder = 872;
+  int32 text = 873;
+  int32 textDecoder = 874;
+  int32 TextFormatDecoder = 875;
+  int32 TextFormatDecodingError = 876;
+  int32 TextFormatDecodingOptions = 877;
+  int32 TextFormatEncodingOptions = 878;
+  int32 TextFormatEncodingVisitor = 879;
+  int32 textFormatString = 880;
+  int32 throwOrIgnore = 881;
+  int32 throws = 882;
+  int32 timeInterval = 883;
+  int32 timeIntervalSince1970 = 884;
+  int32 timeIntervalSinceReferenceDate = 885;
+  int32 Timestamp = 886;
+  int32 toConcrete = 887;
+  int32 total = 888;
+  int32 totalArrayDepth = 889;
+  int32 totalSize = 890;
+  int32 trailingComments = 891;
+  int32 traverse = 892;
+  int32 true = 893;
+  int32 try = 894;
+  int32 type = 895;
+  int32 typealias = 896;
+  int32 TypeEnum = 897;
+  int32 typeName = 898;
+  int32 typePrefix = 899;
+  int32 typeStart = 900;
+  int32 typeUnknown = 901;
+  int32 typeURL = 902;
+  int32 UInt32 = 903;
+  int32 UInt32Value = 904;
+  int32 UInt64 = 905;
+  int32 UInt64Value = 906;
+  int32 UInt8 = 907;
+  int32 unchecked = 908;
+  int32 unicodeScalarLiteral = 909;
+  int32 UnicodeScalarLiteralType = 910;
+  int32 unicodeScalars = 911;
+  int32 UnicodeScalarView = 912;
+  int32 uninterpretedOption = 913;
+  int32 union = 914;
+  int32 uniqueStorage = 915;
+  int32 unknown = 916;
+  int32 unknownFields = 917;
+  int32 UnknownStorage = 918;
+  int32 unpackTo = 919;
+  int32 UnsafeBufferPointer = 920;
+  int32 UnsafeMutablePointer = 921;
+  int32 UnsafeMutableRawBufferPointer = 922;
+  int32 UnsafeRawBufferPointer = 923;
+  int32 UnsafeRawPointer = 924;
+  int32 unverifiedLazy = 925;
+  int32 updatedOptions = 926;
+  int32 url = 927;
+  int32 useDeterministicOrdering = 928;
+  int32 utf8 = 929;
+  int32 utf8Ptr = 930;
+  int32 utf8ToDouble = 931;
+  int32 utf8Validation = 932;
+  int32 UTF8View = 933;
+  int32 v = 934;
+  int32 value = 935;
+  int32 valueField = 936;
+  int32 values = 937;
+  int32 ValueType = 938;
+  int32 var = 939;
+  int32 verification = 940;
+  int32 VerificationState = 941;
+  int32 Version = 942;
+  int32 versionString = 943;
+  int32 visitExtensionFields = 944;
+  int32 visitExtensionFieldsAsMessageSet = 945;
+  int32 visitMapField = 946;
+  int32 visitor = 947;
+  int32 visitPacked = 948;
+  int32 visitPackedBoolField = 949;
+  int32 visitPackedDoubleField = 950;
+  int32 visitPackedEnumField = 951;
+  int32 visitPackedFixed32Field = 952;
+  int32 visitPackedFixed64Field = 953;
+  int32 visitPackedFloatField = 954;
+  int32 visitPackedInt32Field = 955;
+  int32 visitPackedInt64Field = 956;
+  int32 visitPackedSFixed32Field = 957;
+  int32 visitPackedSFixed64Field = 958;
+  int32 visitPackedSInt32Field = 959;
+  int32 visitPackedSInt64Field = 960;
+  int32 visitPackedUInt32Field = 961;
+  int32 visitPackedUInt64Field = 962;
+  int32 visitRepeated = 963;
+  int32 visitRepeatedBoolField = 964;
+  int32 visitRepeatedBytesField = 965;
+  int32 visitRepeatedDoubleField = 966;
+  int32 visitRepeatedEnumField = 967;
+  int32 visitRepeatedFixed32Field = 968;
+  int32 visitRepeatedFixed64Field = 969;
+  int32 visitRepeatedFloatField = 970;
+  int32 visitRepeatedGroupField = 971;
+  int32 visitRepeatedInt32Field = 972;
+  int32 visitRepeatedInt64Field = 973;
+  int32 visitRepeatedMessageField = 974;
+  int32 visitRepeatedSFixed32Field = 975;
+  int32 visitRepeatedSFixed64Field = 976;
+  int32 visitRepeatedSInt32Field = 977;
+  int32 visitRepeatedSInt64Field = 978;
+  int32 visitRepeatedStringField = 979;
+  int32 visitRepeatedUInt32Field = 980;
+  int32 visitRepeatedUInt64Field = 981;
+  int32 visitSingular = 982;
+  int32 visitSingularBoolField = 983;
+  int32 visitSingularBytesField = 984;
+  int32 visitSingularDoubleField = 985;
+  int32 visitSingularEnumField = 986;
+  int32 visitSingularFixed32Field = 987;
+  int32 visitSingularFixed64Field = 988;
+  int32 visitSingularFloatField = 989;
+  int32 visitSingularGroupField = 990;
+  int32 visitSingularInt32Field = 991;
+  int32 visitSingularInt64Field = 992;
+  int32 visitSingularMessageField = 993;
+  int32 visitSingularSFixed32Field = 994;
+  int32 visitSingularSFixed64Field = 995;
+  int32 visitSingularSInt32Field = 996;
+  int32 visitSingularSInt64Field = 997;
+  int32 visitSingularStringField = 998;
+  int32 visitSingularUInt32Field = 999;
+  int32 visitSingularUInt64Field = 1000;
+  int32 visitUnknown = 1001;
+  int32 wasDecoded = 1002;
+  int32 weak = 1003;
+  int32 weakDependency = 1004;
+  int32 where = 1005;
+  int32 wireFormat = 1006;
+  int32 with = 1007;
+  int32 withUnsafeBytes = 1008;
+  int32 withUnsafeMutableBytes = 1009;
+  int32 work = 1010;
+  int32 Wrapped = 1011;
+  int32 WrappedType = 1012;
+  int32 wrappedValue = 1013;
+  int32 written = 1014;
+  int32 yday = 1015;
 }
diff --git a/Protos/SwiftProtobufTests/generated_swift_names_messages.proto b/Protos/SwiftProtobufTests/generated_swift_names_messages.proto
index c0a1ccc3f..d488df0cc 100644
--- a/Protos/SwiftProtobufTests/generated_swift_names_messages.proto
+++ b/Protos/SwiftProtobufTests/generated_swift_names_messages.proto
@@ -281,6 +281,7 @@ message GeneratedSwiftReservedMessages {
   message EnumValueOptions { int32 EnumValueOptions = 1; }
   message Equatable { int32 Equatable = 1; }
   message Error { int32 Error = 1; }
+  message escaping { int32 escaping = 1; }
   message ExpressibleByArrayLiteral { int32 ExpressibleByArrayLiteral = 1; }
   message ExpressibleByDictionaryLiteral { int32 ExpressibleByDictionaryLiteral = 1; }
   message ext { int32 ext = 1; }
@@ -292,6 +293,8 @@ message GeneratedSwiftReservedMessages {
   message extension { int32 extension = 1; }
   message ExtensionField { int32 ExtensionField = 1; }
   message extensionFieldNumber { int32 extensionFieldNumber = 1; }
+  message extensionFields { int32 extensionFields = 1; }
+  message extensionFieldsAsMessageSet { int32 extensionFieldsAsMessageSet = 1; }
   message ExtensionFieldValueSet { int32 ExtensionFieldValueSet = 1; }
   message ExtensionMap { int32 ExtensionMap = 1; }
   message extensionRange { int32 extensionRange = 1; }
@@ -349,6 +352,7 @@ message GeneratedSwiftReservedMessages {
   message GeneratedCodeInfo { int32 GeneratedCodeInfo = 1; }
   message get { int32 get = 1; }
   message getExtensionValue { int32 getExtensionValue = 1; }
+  message getValue { int32 getValue = 1; }
   message googleapis { int32 googleapis = 1; }
   message Google_Protobuf_Any { int32 Google_Protobuf_Any = 1; }
   message Google_Protobuf_Api { int32 Google_Protobuf_Api = 1; }
@@ -526,6 +530,7 @@ message GeneratedSwiftReservedMessages {
   message isExtension { int32 isExtension = 1; }
   message isInitialized { int32 isInitialized = 1; }
   message isNegative { int32 isNegative = 1; }
+  message isUnset { int32 isUnset = 1; }
   message itemTagsEncodedSize { int32 itemTagsEncodedSize = 1; }
   message iterator { int32 iterator = 1; }
   message javaGenerateEqualsAndHash { int32 javaGenerateEqualsAndHash = 1; }
@@ -580,6 +585,7 @@ message GeneratedSwiftReservedMessages {
   message major { int32 major = 1; }
   message makeAsyncIterator { int32 makeAsyncIterator = 1; }
   message makeIterator { int32 makeIterator = 1; }
+  message map { int32 map = 1; }
   message mapEntry { int32 mapEntry = 1; }
   message MapKeyType { int32 MapKeyType = 1; }
   message mapToMessages { int32 mapToMessages = 1; }
@@ -636,6 +642,7 @@ message GeneratedSwiftReservedMessages {
   message numberValue { int32 numberValue = 1; }
   message objcClassPrefix { int32 objcClassPrefix = 1; }
   message of { int32 of = 1; }
+  message oneOf { int32 oneOf = 1; }
   message oneofDecl { int32 oneofDecl = 1; }
   message OneofDescriptorProto { int32 OneofDescriptorProto = 1; }
   message oneofIndex { int32 oneofIndex = 1; }
@@ -659,8 +666,22 @@ message GeneratedSwiftReservedMessages {
   message p { int32 p = 1; }
   message package { int32 package = 1; }
   message packed { int32 packed = 1; }
+  message packedBool { int32 packedBool = 1; }
+  message packedDouble { int32 packedDouble = 1; }
+  message packedEnum { int32 packedEnum = 1; }
   message PackedEnumExtensionField { int32 PackedEnumExtensionField = 1; }
   message PackedExtensionField { int32 PackedExtensionField = 1; }
+  message packedFixed32 { int32 packedFixed32 = 1; }
+  message packedFixed64 { int32 packedFixed64 = 1; }
+  message packedFloat { int32 packedFloat = 1; }
+  message packedInt32 { int32 packedInt32 = 1; }
+  message packedInt64 { int32 packedInt64 = 1; }
+  message packedSFixed32 { int32 packedSFixed32 = 1; }
+  message packedSFixed64 { int32 packedSFixed64 = 1; }
+  message packedSInt32 { int32 packedSInt32 = 1; }
+  message packedSInt64 { int32 packedSInt64 = 1; }
+  message packedUInt32 { int32 packedUInt32 = 1; }
+  message packedUInt64 { int32 packedUInt64 = 1; }
   message padding { int32 padding = 1; }
   message parent { int32 parent = 1; }
   message parse { int32 parse = 1; }
@@ -737,11 +758,29 @@ message GeneratedSwiftReservedMessages {
   message readBytes { int32 readBytes = 1; }
   message register { int32 register = 1; }
   message repeated { int32 repeated = 1; }
+  message repeatedBool { int32 repeatedBool = 1; }
+  message repeatedBytes { int32 repeatedBytes = 1; }
+  message repeatedDouble { int32 repeatedDouble = 1; }
+  message repeatedEnum { int32 repeatedEnum = 1; }
   message RepeatedEnumExtensionField { int32 RepeatedEnumExtensionField = 1; }
   message RepeatedExtensionField { int32 RepeatedExtensionField = 1; }
   message repeatedFieldEncoding { int32 repeatedFieldEncoding = 1; }
+  message repeatedFixed32 { int32 repeatedFixed32 = 1; }
+  message repeatedFixed64 { int32 repeatedFixed64 = 1; }
+  message repeatedFloat { int32 repeatedFloat = 1; }
+  message repeatedGroup { int32 repeatedGroup = 1; }
   message RepeatedGroupExtensionField { int32 RepeatedGroupExtensionField = 1; }
+  message repeatedInt32 { int32 repeatedInt32 = 1; }
+  message repeatedInt64 { int32 repeatedInt64 = 1; }
+  message repeatedMessage { int32 repeatedMessage = 1; }
   message RepeatedMessageExtensionField { int32 RepeatedMessageExtensionField = 1; }
+  message repeatedSFixed32 { int32 repeatedSFixed32 = 1; }
+  message repeatedSFixed64 { int32 repeatedSFixed64 = 1; }
+  message repeatedSInt32 { int32 repeatedSInt32 = 1; }
+  message repeatedSInt64 { int32 repeatedSInt64 = 1; }
+  message repeatedString { int32 repeatedString = 1; }
+  message repeatedUInt32 { int32 repeatedUInt32 = 1; }
+  message repeatedUInt64 { int32 repeatedUInt64 = 1; }
   message repeating { int32 repeating = 1; }
   message requestStreaming { int32 requestStreaming = 1; }
   message requestTypeURL { int32 requestTypeURL = 1; }
@@ -779,6 +818,24 @@ message GeneratedSwiftReservedMessages {
   message setExtensionValue { int32 setExtensionValue = 1; }
   message shift { int32 shift = 1; }
   message SimpleExtensionMap { int32 SimpleExtensionMap = 1; }
+  message singularBool { int32 singularBool = 1; }
+  message singularBytes { int32 singularBytes = 1; }
+  message singularDouble { int32 singularDouble = 1; }
+  message singularEnum { int32 singularEnum = 1; }
+  message singularFixed32 { int32 singularFixed32 = 1; }
+  message singularFixed64 { int32 singularFixed64 = 1; }
+  message singularFloat { int32 singularFloat = 1; }
+  message singularGroup { int32 singularGroup = 1; }
+  message singularInt32 { int32 singularInt32 = 1; }
+  message singularInt64 { int32 singularInt64 = 1; }
+  message singularMessage { int32 singularMessage = 1; }
+  message singularSFixed32 { int32 singularSFixed32 = 1; }
+  message singularSFixed64 { int32 singularSFixed64 = 1; }
+  message singularSInt32 { int32 singularSInt32 = 1; }
+  message singularSInt64 { int32 singularSInt64 = 1; }
+  message singularString { int32 singularString = 1; }
+  message singularUInt32 { int32 singularUInt32 = 1; }
+  message singularUInt64 { int32 singularUInt64 = 1; }
   message size { int32 size = 1; }
   message sizer { int32 sizer = 1; }
   message source { int32 source = 1; }
@@ -833,6 +890,7 @@ message GeneratedSwiftReservedMessages {
   message timeIntervalSince1970 { int32 timeIntervalSince1970 = 1; }
   message timeIntervalSinceReferenceDate { int32 timeIntervalSinceReferenceDate = 1; }
   message Timestamp { int32 Timestamp = 1; }
+  message toConcrete { int32 toConcrete = 1; }
   message total { int32 total = 1; }
   message totalArrayDepth { int32 totalArrayDepth = 1; }
   message totalSize { int32 totalSize = 1; }
diff --git a/Sources/Conformance/conformance.pb.swift b/Sources/Conformance/conformance.pb.swift
index ef099db7b..ef8e0e3b7 100644
--- a/Sources/Conformance/conformance.pb.swift
+++ b/Sources/Conformance/conformance.pb.swift
@@ -455,12 +455,10 @@ extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageI
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.failure.isEmpty {
-      try visitor.visitRepeatedStringField(value: self.failure, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .repeatedString({ $0.failure }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: Conformance_FailureSet, rhs: Conformance_FailureSet) -> Bool {
     if lhs.failure != rhs.failure {return false}
@@ -531,50 +529,38 @@ extension Conformance_ConformanceRequest: SwiftProtobuf.Message, SwiftProtobuf._
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    switch self.payload {
-    case .protobufPayload?: try {
-      guard case .protobufPayload(let v)? = self.payload else { preconditionFailure() }
-      try visitor.visitSingularBytesField(value: v, fieldNumber: 1)
-    }()
-    case .jsonPayload?: try {
-      guard case .jsonPayload(let v)? = self.payload else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    }()
-    default: break
-    }
-    if self.requestedOutputFormat != .unspecified {
-      try visitor.visitSingularEnumField(value: self.requestedOutputFormat, fieldNumber: 3)
-    }
-    if !self.messageType.isEmpty {
-      try visitor.visitSingularStringField(value: self.messageType, fieldNumber: 4)
-    }
-    if self.testCategory != .unspecifiedTest {
-      try visitor.visitSingularEnumField(value: self.testCategory, fieldNumber: 5)
-    }
-    try { if let v = self._jspbEncodingOptions {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 6)
-    } }()
-    switch self.payload {
-    case .jspbPayload?: try {
-      guard case .jspbPayload(let v)? = self.payload else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 7)
-    }()
-    case .textPayload?: try {
-      guard case .textPayload(let v)? = self.payload else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 8)
-    }()
-    default: break
-    }
-    if self.printUnknownFields != false {
-      try visitor.visitSingularBoolField(value: self.printUnknownFields, fieldNumber: 9)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .oneOf({ $0.payload }) {
+      switch $0 {
+      case .protobufPayload:
+        return _oneOfField_protobufPayload
+      case .jsonPayload:
+        return _oneOfField_jsonPayload
+      default:
+        return nil
+      }
+    },
+    .singularEnum({ $0.requestedOutputFormat }, fieldNumber: 3, defaultValue: .unspecified),
+    .singularString({ $0.messageType }, fieldNumber: 4),
+    .singularEnum({ $0.testCategory }, fieldNumber: 5, defaultValue: .unspecifiedTest),
+    .singularMessage({ $0.jspbEncodingOptions }, fieldNumber: 6, isUnset: { $0._jspbEncodingOptions == nil }),
+    .oneOf({ $0.payload }) {
+      switch $0 {
+      case .jspbPayload:
+        return _oneOfField_jspbPayload
+      case .textPayload:
+        return _oneOfField_textPayload
+      default:
+        return nil
+      }
+    },
+    .singularBool({ $0.printUnknownFields }, fieldNumber: 9),
+  ]
+  private static let _oneOfField_protobufPayload: Field<Self> = .singularBytes({ $0.protobufPayload }, fieldNumber: 1, isUnset: { _ in false })
+  private static let _oneOfField_jsonPayload: Field<Self> = .singularString({ $0.jsonPayload }, fieldNumber: 2, isUnset: { _ in false })
+  private static let _oneOfField_jspbPayload: Field<Self> = .singularString({ $0.jspbPayload }, fieldNumber: 7, isUnset: { _ in false })
+  private static let _oneOfField_textPayload: Field<Self> = .singularString({ $0.textPayload }, fieldNumber: 8, isUnset: { _ in false })
+
 
   static func ==(lhs: Conformance_ConformanceRequest, rhs: Conformance_ConformanceRequest) -> Bool {
     if lhs.payload != rhs.payload {return false}
@@ -685,52 +671,40 @@ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf.
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    switch self.result {
-    case .parseError?: try {
-      guard case .parseError(let v)? = self.result else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    }()
-    case .runtimeError?: try {
-      guard case .runtimeError(let v)? = self.result else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    }()
-    case .protobufPayload?: try {
-      guard case .protobufPayload(let v)? = self.result else { preconditionFailure() }
-      try visitor.visitSingularBytesField(value: v, fieldNumber: 3)
-    }()
-    case .jsonPayload?: try {
-      guard case .jsonPayload(let v)? = self.result else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 4)
-    }()
-    case .skipped?: try {
-      guard case .skipped(let v)? = self.result else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 5)
-    }()
-    case .serializeError?: try {
-      guard case .serializeError(let v)? = self.result else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 6)
-    }()
-    case .jspbPayload?: try {
-      guard case .jspbPayload(let v)? = self.result else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 7)
-    }()
-    case .textPayload?: try {
-      guard case .textPayload(let v)? = self.result else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 8)
-    }()
-    case .timeoutError?: try {
-      guard case .timeoutError(let v)? = self.result else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 9)
-    }()
-    case nil: break
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .oneOf({ $0.result }) {
+      switch $0 {
+      case .parseError:
+        return _oneOfField_parseError
+      case .runtimeError:
+        return _oneOfField_runtimeError
+      case .protobufPayload:
+        return _oneOfField_protobufPayload
+      case .jsonPayload:
+        return _oneOfField_jsonPayload
+      case .skipped:
+        return _oneOfField_skipped
+      case .serializeError:
+        return _oneOfField_serializeError
+      case .jspbPayload:
+        return _oneOfField_jspbPayload
+      case .textPayload:
+        return _oneOfField_textPayload
+      case .timeoutError:
+        return _oneOfField_timeoutError
+      }
+    },
+  ]
+  private static let _oneOfField_parseError: Field<Self> = .singularString({ $0.parseError }, fieldNumber: 1, isUnset: { _ in false })
+  private static let _oneOfField_runtimeError: Field<Self> = .singularString({ $0.runtimeError }, fieldNumber: 2, isUnset: { _ in false })
+  private static let _oneOfField_protobufPayload: Field<Self> = .singularBytes({ $0.protobufPayload }, fieldNumber: 3, isUnset: { _ in false })
+  private static let _oneOfField_jsonPayload: Field<Self> = .singularString({ $0.jsonPayload }, fieldNumber: 4, isUnset: { _ in false })
+  private static let _oneOfField_skipped: Field<Self> = .singularString({ $0.skipped }, fieldNumber: 5, isUnset: { _ in false })
+  private static let _oneOfField_serializeError: Field<Self> = .singularString({ $0.serializeError }, fieldNumber: 6, isUnset: { _ in false })
+  private static let _oneOfField_jspbPayload: Field<Self> = .singularString({ $0.jspbPayload }, fieldNumber: 7, isUnset: { _ in false })
+  private static let _oneOfField_textPayload: Field<Self> = .singularString({ $0.textPayload }, fieldNumber: 8, isUnset: { _ in false })
+  private static let _oneOfField_timeoutError: Field<Self> = .singularString({ $0.timeoutError }, fieldNumber: 9, isUnset: { _ in false })
+
 
   static func ==(lhs: Conformance_ConformanceResponse, rhs: Conformance_ConformanceResponse) -> Bool {
     if lhs.result != rhs.result {return false}
@@ -757,12 +731,10 @@ extension Conformance_JspbEncodingConfig: SwiftProtobuf.Message, SwiftProtobuf._
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.useJspbArrayAnyFormat != false {
-      try visitor.visitSingularBoolField(value: self.useJspbArrayAnyFormat, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularBool({ $0.useJspbArrayAnyFormat }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: Conformance_JspbEncodingConfig, rhs: Conformance_JspbEncodingConfig) -> Bool {
     if lhs.useJspbArrayAnyFormat != rhs.useJspbArrayAnyFormat {return false}
diff --git a/Sources/Conformance/test_messages_proto2.pb.swift b/Sources/Conformance/test_messages_proto2.pb.swift
index 5cadbe993..881df1e34 100644
--- a/Sources/Conformance/test_messages_proto2.pb.swift
+++ b/Sources/Conformance/test_messages_proto2.pb.swift
@@ -2710,427 +2710,165 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._optionalInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._optionalInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._optionalUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._optionalUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._optionalSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._optionalSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._optionalFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._optionalFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._optionalSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._optionalSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._optionalFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._optionalDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._optionalBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._optionalString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._optionalBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._optionalNestedMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._optionalForeignMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 19)
-      } }()
-      try { if let v = _storage._optionalNestedEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 21)
-      } }()
-      try { if let v = _storage._optionalForeignEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 22)
-      } }()
-      try { if let v = _storage._optionalStringPiece {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 24)
-      } }()
-      try { if let v = _storage._optionalCord {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 25)
-      } }()
-      try { if let v = _storage._recursiveMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 27)
-      } }()
-      if !_storage._repeatedInt32.isEmpty {
-        try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31)
-      }
-      if !_storage._repeatedInt64.isEmpty {
-        try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32)
-      }
-      if !_storage._repeatedUint32.isEmpty {
-        try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33)
-      }
-      if !_storage._repeatedUint64.isEmpty {
-        try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34)
-      }
-      if !_storage._repeatedSint32.isEmpty {
-        try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35)
-      }
-      if !_storage._repeatedSint64.isEmpty {
-        try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36)
-      }
-      if !_storage._repeatedFixed32.isEmpty {
-        try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37)
-      }
-      if !_storage._repeatedFixed64.isEmpty {
-        try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38)
-      }
-      if !_storage._repeatedSfixed32.isEmpty {
-        try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39)
-      }
-      if !_storage._repeatedSfixed64.isEmpty {
-        try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40)
-      }
-      if !_storage._repeatedFloat.isEmpty {
-        try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41)
-      }
-      if !_storage._repeatedDouble.isEmpty {
-        try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42)
-      }
-      if !_storage._repeatedBool.isEmpty {
-        try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43)
-      }
-      if !_storage._repeatedString.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44)
-      }
-      if !_storage._repeatedBytes.isEmpty {
-        try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45)
-      }
-      if !_storage._repeatedNestedMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48)
-      }
-      if !_storage._repeatedForeignMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49)
-      }
-      if !_storage._repeatedNestedEnum.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51)
-      }
-      if !_storage._repeatedForeignEnum.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52)
-      }
-      if !_storage._repeatedStringPiece.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54)
-      }
-      if !_storage._repeatedCord.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55)
-      }
-      if !_storage._mapInt32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapInt32Int32, fieldNumber: 56)
-      }
-      if !_storage._mapInt64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapInt64Int64, fieldNumber: 57)
-      }
-      if !_storage._mapUint32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapUint32Uint32, fieldNumber: 58)
-      }
-      if !_storage._mapUint64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapUint64Uint64, fieldNumber: 59)
-      }
-      if !_storage._mapSint32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSint32Sint32, fieldNumber: 60)
-      }
-      if !_storage._mapSint64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSint64Sint64, fieldNumber: 61)
-      }
-      if !_storage._mapFixed32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62)
-      }
-      if !_storage._mapFixed64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63)
-      }
-      if !_storage._mapSfixed32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64)
-      }
-      if !_storage._mapSfixed64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65)
-      }
-      if !_storage._mapInt32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapInt32Float, fieldNumber: 66)
-      }
-      if !_storage._mapInt32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapInt32Double, fieldNumber: 67)
-      }
-      if !_storage._mapBoolBool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapBoolBool, fieldNumber: 68)
-      }
-      if !_storage._mapStringString.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, value: _storage._mapStringString, fieldNumber: 69)
-      }
-      if !_storage._mapStringBytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapStringBytes, fieldNumber: 70)
-      }
-      if !_storage._mapStringNestedMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage>.self, value: _storage._mapStringNestedMessage, fieldNumber: 71)
-      }
-      if !_storage._mapStringForeignMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_ForeignMessageProto2>.self, value: _storage._mapStringForeignMessage, fieldNumber: 72)
-      }
-      if !_storage._mapStringNestedEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum>.self, value: _storage._mapStringNestedEnum, fieldNumber: 73)
-      }
-      if !_storage._mapStringForeignEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_ForeignEnumProto2>.self, value: _storage._mapStringForeignEnum, fieldNumber: 74)
-      }
-      if !_storage._packedInt32.isEmpty {
-        try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75)
-      }
-      if !_storage._packedInt64.isEmpty {
-        try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76)
-      }
-      if !_storage._packedUint32.isEmpty {
-        try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77)
-      }
-      if !_storage._packedUint64.isEmpty {
-        try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78)
-      }
-      if !_storage._packedSint32.isEmpty {
-        try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79)
-      }
-      if !_storage._packedSint64.isEmpty {
-        try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80)
-      }
-      if !_storage._packedFixed32.isEmpty {
-        try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81)
-      }
-      if !_storage._packedFixed64.isEmpty {
-        try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82)
-      }
-      if !_storage._packedSfixed32.isEmpty {
-        try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83)
-      }
-      if !_storage._packedSfixed64.isEmpty {
-        try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84)
-      }
-      if !_storage._packedFloat.isEmpty {
-        try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85)
-      }
-      if !_storage._packedDouble.isEmpty {
-        try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86)
-      }
-      if !_storage._packedBool.isEmpty {
-        try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87)
-      }
-      if !_storage._packedNestedEnum.isEmpty {
-        try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88)
-      }
-      if !_storage._unpackedInt32.isEmpty {
-        try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89)
-      }
-      if !_storage._unpackedInt64.isEmpty {
-        try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90)
-      }
-      if !_storage._unpackedUint32.isEmpty {
-        try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91)
-      }
-      if !_storage._unpackedUint64.isEmpty {
-        try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92)
-      }
-      if !_storage._unpackedSint32.isEmpty {
-        try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93)
-      }
-      if !_storage._unpackedSint64.isEmpty {
-        try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94)
-      }
-      if !_storage._unpackedFixed32.isEmpty {
-        try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95)
-      }
-      if !_storage._unpackedFixed64.isEmpty {
-        try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96)
-      }
-      if !_storage._unpackedSfixed32.isEmpty {
-        try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97)
-      }
-      if !_storage._unpackedSfixed64.isEmpty {
-        try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98)
-      }
-      if !_storage._unpackedFloat.isEmpty {
-        try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99)
-      }
-      if !_storage._unpackedDouble.isEmpty {
-        try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100)
-      }
-      if !_storage._unpackedBool.isEmpty {
-        try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101)
-      }
-      if !_storage._unpackedNestedEnum.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102)
-      }
-      switch _storage._oneofField {
-      case .oneofUint32?: try {
-        guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111)
-      }()
-      case .oneofNestedMessage?: try {
-        guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 112)
-      }()
-      case .oneofString?: try {
-        guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularStringField(value: v, fieldNumber: 113)
-      }()
-      case .oneofBytes?: try {
-        guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 114)
-      }()
-      case .oneofBool?: try {
-        guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 115)
-      }()
-      case .oneofUint64?: try {
-        guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116)
-      }()
-      case .oneofFloat?: try {
-        guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 117)
-      }()
-      case .oneofDouble?: try {
-        guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 118)
-      }()
-      case .oneofEnum?: try {
-        guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 119)
-      }()
-      case nil: break
-      }
-      try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201)
-      try { if let v = _storage._data {
-        try visitor.visitSingularGroupField(value: v, fieldNumber: 201)
-      } }()
-      try { if let v = _storage._defaultInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 241)
-      } }()
-      try { if let v = _storage._defaultInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 242)
-      } }()
-      try { if let v = _storage._defaultUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243)
-      } }()
-      try { if let v = _storage._defaultUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244)
-      } }()
-      try { if let v = _storage._defaultSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245)
-      } }()
-      try { if let v = _storage._defaultSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246)
-      } }()
-      try { if let v = _storage._defaultFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247)
-      } }()
-      try { if let v = _storage._defaultFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248)
-      } }()
-      try { if let v = _storage._defaultSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249)
-      } }()
-      try { if let v = _storage._defaultSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250)
-      } }()
-      try { if let v = _storage._defaultFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 251)
-      } }()
-      try { if let v = _storage._defaultDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 252)
-      } }()
-      try { if let v = _storage._defaultBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 253)
-      } }()
-      try { if let v = _storage._defaultString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 254)
-      } }()
-      try { if let v = _storage._defaultBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 255)
-      } }()
-      try { if let v = _storage._fieldname1 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 401)
-      } }()
-      try { if let v = _storage._fieldName2 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 402)
-      } }()
-      try { if let v = _storage._fieldName3 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 403)
-      } }()
-      try { if let v = _storage._field_Name4_ {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 404)
-      } }()
-      try { if let v = _storage._field0Name5 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 405)
-      } }()
-      try { if let v = _storage._field0Name6 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 406)
-      } }()
-      try { if let v = _storage._fieldName7 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 407)
-      } }()
-      try { if let v = _storage._fieldName8 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 408)
-      } }()
-      try { if let v = _storage._fieldName9 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 409)
-      } }()
-      try { if let v = _storage._fieldName10 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 410)
-      } }()
-      try { if let v = _storage._fieldName11 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 411)
-      } }()
-      try { if let v = _storage._fieldName12 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 412)
-      } }()
-      try { if let v = _storage.__FieldName13 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 413)
-      } }()
-      try { if let v = _storage.__FieldName14 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 414)
-      } }()
-      try { if let v = _storage._field_Name15 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 415)
-      } }()
-      try { if let v = _storage._field_Name16 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 416)
-      } }()
-      try { if let v = _storage._fieldName17__ {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 417)
-      } }()
-      try { if let v = _storage._fieldName18__ {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 418)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalInt32 }, fieldNumber: 1, isUnset: { $0._storage._optionalInt32 == nil }),
+    .singularInt64({ $0.optionalInt64 }, fieldNumber: 2, isUnset: { $0._storage._optionalInt64 == nil }),
+    .singularUInt32({ $0.optionalUint32 }, fieldNumber: 3, isUnset: { $0._storage._optionalUint32 == nil }),
+    .singularUInt64({ $0.optionalUint64 }, fieldNumber: 4, isUnset: { $0._storage._optionalUint64 == nil }),
+    .singularSInt32({ $0.optionalSint32 }, fieldNumber: 5, isUnset: { $0._storage._optionalSint32 == nil }),
+    .singularSInt64({ $0.optionalSint64 }, fieldNumber: 6, isUnset: { $0._storage._optionalSint64 == nil }),
+    .singularFixed32({ $0.optionalFixed32 }, fieldNumber: 7, isUnset: { $0._storage._optionalFixed32 == nil }),
+    .singularFixed64({ $0.optionalFixed64 }, fieldNumber: 8, isUnset: { $0._storage._optionalFixed64 == nil }),
+    .singularSFixed32({ $0.optionalSfixed32 }, fieldNumber: 9, isUnset: { $0._storage._optionalSfixed32 == nil }),
+    .singularSFixed64({ $0.optionalSfixed64 }, fieldNumber: 10, isUnset: { $0._storage._optionalSfixed64 == nil }),
+    .singularFloat({ $0.optionalFloat }, fieldNumber: 11, isUnset: { $0._storage._optionalFloat == nil }),
+    .singularDouble({ $0.optionalDouble }, fieldNumber: 12, isUnset: { $0._storage._optionalDouble == nil }),
+    .singularBool({ $0.optionalBool }, fieldNumber: 13, isUnset: { $0._storage._optionalBool == nil }),
+    .singularString({ $0.optionalString }, fieldNumber: 14, isUnset: { $0._storage._optionalString == nil }),
+    .singularBytes({ $0.optionalBytes }, fieldNumber: 15, isUnset: { $0._storage._optionalBytes == nil }),
+    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
+    .singularMessage({ $0.optionalForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._optionalForeignMessage == nil }),
+    .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, isUnset: { $0._storage._optionalNestedEnum == nil }),
+    .singularEnum({ $0.optionalForeignEnum }, fieldNumber: 22, isUnset: { $0._storage._optionalForeignEnum == nil }),
+    .singularString({ $0.optionalStringPiece }, fieldNumber: 24, isUnset: { $0._storage._optionalStringPiece == nil }),
+    .singularString({ $0.optionalCord }, fieldNumber: 25, isUnset: { $0._storage._optionalCord == nil }),
+    .singularMessage({ $0.recursiveMessage }, fieldNumber: 27, isUnset: { $0._storage._recursiveMessage == nil }),
+    .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
+    .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
+    .repeatedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
+    .repeatedUInt64({ $0.repeatedUint64 }, fieldNumber: 34),
+    .repeatedSInt32({ $0.repeatedSint32 }, fieldNumber: 35),
+    .repeatedSInt64({ $0.repeatedSint64 }, fieldNumber: 36),
+    .repeatedFixed32({ $0.repeatedFixed32 }, fieldNumber: 37),
+    .repeatedFixed64({ $0.repeatedFixed64 }, fieldNumber: 38),
+    .repeatedSFixed32({ $0.repeatedSfixed32 }, fieldNumber: 39),
+    .repeatedSFixed64({ $0.repeatedSfixed64 }, fieldNumber: 40),
+    .repeatedFloat({ $0.repeatedFloat }, fieldNumber: 41),
+    .repeatedDouble({ $0.repeatedDouble }, fieldNumber: 42),
+    .repeatedBool({ $0.repeatedBool }, fieldNumber: 43),
+    .repeatedString({ $0.repeatedString }, fieldNumber: 44),
+    .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
+    .repeatedMessage({ $0.repeatedNestedMessage }, fieldNumber: 48),
+    .repeatedMessage({ $0.repeatedForeignMessage }, fieldNumber: 49),
+    .repeatedEnum({ $0.repeatedNestedEnum }, fieldNumber: 51),
+    .repeatedEnum({ $0.repeatedForeignEnum }, fieldNumber: 52),
+    .repeatedString({ $0.repeatedStringPiece }, fieldNumber: 54),
+    .repeatedString({ $0.repeatedCord }, fieldNumber: 55),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 56),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 57),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 58),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 59),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 60),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 61),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 62),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 63),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 64),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 65),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 66),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 67),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 68),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 69),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0.mapStringBytes }, fieldNumber: 70),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage>.self, { $0.mapStringNestedMessage }, fieldNumber: 71),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_ForeignMessageProto2>.self, { $0.mapStringForeignMessage }, fieldNumber: 72),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum>.self, { $0.mapStringNestedEnum }, fieldNumber: 73),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_ForeignEnumProto2>.self, { $0.mapStringForeignEnum }, fieldNumber: 74),
+    .packedInt32({ $0.packedInt32 }, fieldNumber: 75),
+    .packedInt64({ $0.packedInt64 }, fieldNumber: 76),
+    .packedUInt32({ $0.packedUint32 }, fieldNumber: 77),
+    .packedUInt64({ $0.packedUint64 }, fieldNumber: 78),
+    .packedSInt32({ $0.packedSint32 }, fieldNumber: 79),
+    .packedSInt64({ $0.packedSint64 }, fieldNumber: 80),
+    .packedFixed32({ $0.packedFixed32 }, fieldNumber: 81),
+    .packedFixed64({ $0.packedFixed64 }, fieldNumber: 82),
+    .packedSFixed32({ $0.packedSfixed32 }, fieldNumber: 83),
+    .packedSFixed64({ $0.packedSfixed64 }, fieldNumber: 84),
+    .packedFloat({ $0.packedFloat }, fieldNumber: 85),
+    .packedDouble({ $0.packedDouble }, fieldNumber: 86),
+    .packedBool({ $0.packedBool }, fieldNumber: 87),
+    .packedEnum({ $0.packedNestedEnum }, fieldNumber: 88),
+    .repeatedInt32({ $0.unpackedInt32 }, fieldNumber: 89),
+    .repeatedInt64({ $0.unpackedInt64 }, fieldNumber: 90),
+    .repeatedUInt32({ $0.unpackedUint32 }, fieldNumber: 91),
+    .repeatedUInt64({ $0.unpackedUint64 }, fieldNumber: 92),
+    .repeatedSInt32({ $0.unpackedSint32 }, fieldNumber: 93),
+    .repeatedSInt64({ $0.unpackedSint64 }, fieldNumber: 94),
+    .repeatedFixed32({ $0.unpackedFixed32 }, fieldNumber: 95),
+    .repeatedFixed64({ $0.unpackedFixed64 }, fieldNumber: 96),
+    .repeatedSFixed32({ $0.unpackedSfixed32 }, fieldNumber: 97),
+    .repeatedSFixed64({ $0.unpackedSfixed64 }, fieldNumber: 98),
+    .repeatedFloat({ $0.unpackedFloat }, fieldNumber: 99),
+    .repeatedDouble({ $0.unpackedDouble }, fieldNumber: 100),
+    .repeatedBool({ $0.unpackedBool }, fieldNumber: 101),
+    .repeatedEnum({ $0.unpackedNestedEnum }, fieldNumber: 102),
+    .oneOf({ $0.oneofField }) {
+      switch $0 {
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofNestedMessage:
+        return _oneOfField_oneofNestedMessage
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
+      case .oneofBool:
+        return _oneOfField_oneofBool
+      case .oneofUint64:
+        return _oneOfField_oneofUint64
+      case .oneofFloat:
+        return _oneOfField_oneofFloat
+      case .oneofDouble:
+        return _oneOfField_oneofDouble
+      case .oneofEnum:
+        return _oneOfField_oneofEnum
+      }
+    },
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 120, end: 201),
+    .singularGroup({ $0.data }, fieldNumber: 201, isUnset: { $0._storage._data == nil }),
+    .singularInt32({ $0.defaultInt32 }, fieldNumber: 241, isUnset: { $0._storage._defaultInt32 == nil }),
+    .singularInt64({ $0.defaultInt64 }, fieldNumber: 242, isUnset: { $0._storage._defaultInt64 == nil }),
+    .singularUInt32({ $0.defaultUint32 }, fieldNumber: 243, isUnset: { $0._storage._defaultUint32 == nil }),
+    .singularUInt64({ $0.defaultUint64 }, fieldNumber: 244, isUnset: { $0._storage._defaultUint64 == nil }),
+    .singularSInt32({ $0.defaultSint32 }, fieldNumber: 245, isUnset: { $0._storage._defaultSint32 == nil }),
+    .singularSInt64({ $0.defaultSint64 }, fieldNumber: 246, isUnset: { $0._storage._defaultSint64 == nil }),
+    .singularFixed32({ $0.defaultFixed32 }, fieldNumber: 247, isUnset: { $0._storage._defaultFixed32 == nil }),
+    .singularFixed64({ $0.defaultFixed64 }, fieldNumber: 248, isUnset: { $0._storage._defaultFixed64 == nil }),
+    .singularSFixed32({ $0.defaultSfixed32 }, fieldNumber: 249, isUnset: { $0._storage._defaultSfixed32 == nil }),
+    .singularSFixed64({ $0.defaultSfixed64 }, fieldNumber: 250, isUnset: { $0._storage._defaultSfixed64 == nil }),
+    .singularFloat({ $0.defaultFloat }, fieldNumber: 251, isUnset: { $0._storage._defaultFloat == nil }),
+    .singularDouble({ $0.defaultDouble }, fieldNumber: 252, isUnset: { $0._storage._defaultDouble == nil }),
+    .singularBool({ $0.defaultBool }, fieldNumber: 253, isUnset: { $0._storage._defaultBool == nil }),
+    .singularString({ $0.defaultString }, fieldNumber: 254, isUnset: { $0._storage._defaultString == nil }),
+    .singularBytes({ $0.defaultBytes }, fieldNumber: 255, isUnset: { $0._storage._defaultBytes == nil }),
+    .singularInt32({ $0.fieldname1 }, fieldNumber: 401, isUnset: { $0._storage._fieldname1 == nil }),
+    .singularInt32({ $0.fieldName2 }, fieldNumber: 402, isUnset: { $0._storage._fieldName2 == nil }),
+    .singularInt32({ $0.fieldName3 }, fieldNumber: 403, isUnset: { $0._storage._fieldName3 == nil }),
+    .singularInt32({ $0.field_Name4_ }, fieldNumber: 404, isUnset: { $0._storage._field_Name4_ == nil }),
+    .singularInt32({ $0.field0Name5 }, fieldNumber: 405, isUnset: { $0._storage._field0Name5 == nil }),
+    .singularInt32({ $0.field0Name6 }, fieldNumber: 406, isUnset: { $0._storage._field0Name6 == nil }),
+    .singularInt32({ $0.fieldName7 }, fieldNumber: 407, isUnset: { $0._storage._fieldName7 == nil }),
+    .singularInt32({ $0.fieldName8 }, fieldNumber: 408, isUnset: { $0._storage._fieldName8 == nil }),
+    .singularInt32({ $0.fieldName9 }, fieldNumber: 409, isUnset: { $0._storage._fieldName9 == nil }),
+    .singularInt32({ $0.fieldName10 }, fieldNumber: 410, isUnset: { $0._storage._fieldName10 == nil }),
+    .singularInt32({ $0.fieldName11 }, fieldNumber: 411, isUnset: { $0._storage._fieldName11 == nil }),
+    .singularInt32({ $0.fieldName12 }, fieldNumber: 412, isUnset: { $0._storage._fieldName12 == nil }),
+    .singularInt32({ $0._FieldName13 }, fieldNumber: 413, isUnset: { $0._storage.__FieldName13 == nil }),
+    .singularInt32({ $0._FieldName14 }, fieldNumber: 414, isUnset: { $0._storage.__FieldName14 == nil }),
+    .singularInt32({ $0.field_Name15 }, fieldNumber: 415, isUnset: { $0._storage._field_Name15 == nil }),
+    .singularInt32({ $0.field_Name16 }, fieldNumber: 416, isUnset: { $0._storage._field_Name16 == nil }),
+    .singularInt32({ $0.fieldName17__ }, fieldNumber: 417, isUnset: { $0._storage._fieldName17__ == nil }),
+    .singularInt32({ $0.fieldName18__ }, fieldNumber: 418, isUnset: { $0._storage._fieldName18__ == nil }),
+  ]
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
+  private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 115, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint64: Field<Self> = .singularUInt64({ $0.oneofUint64 }, fieldNumber: 116, isUnset: { _ in false })
+  private static let _oneOfField_oneofFloat: Field<Self> = .singularFloat({ $0.oneofFloat }, fieldNumber: 117, isUnset: { _ in false })
+  private static let _oneOfField_oneofDouble: Field<Self> = .singularDouble({ $0.oneofDouble }, fieldNumber: 118, isUnset: { _ in false })
+  private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 119, isUnset: { _ in false })
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -3332,21 +3070,11 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._a {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._corecursive {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._storage._a == nil }),
+    .singularMessage({ $0.corecursive }, fieldNumber: 2, isUnset: { $0._storage._corecursive == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -3384,19 +3112,11 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: SwiftProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupInt32 {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 202)
-    } }()
-    try { if let v = self._groupUint32 {
-      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupInt32 }, fieldNumber: 202, isUnset: { $0._groupInt32 == nil }),
+    .singularUInt32({ $0.groupUint32 }, fieldNumber: 203, isUnset: { $0._groupUint32 == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage) -> Bool {
     if lhs._groupInt32 != rhs._groupInt32 {return false}
@@ -3419,10 +3139,10 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect: Swif
     try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect.self)
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFieldsAsMessageSet({ $0._protobuf_extensionFieldValues }, start: 4, end: 2147483647),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -3449,16 +3169,10 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtens
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._str {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 25)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularString({ $0.str }, fieldNumber: 25, isUnset: { $0._str == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1) -> Bool {
     if lhs._str != rhs._str {return false}
@@ -3485,16 +3199,10 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtens
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._i {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 9)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.i }, fieldNumber: 9, isUnset: { $0._i == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2) -> Bool {
     if lhs._i != rhs._i {return false}
@@ -3521,16 +3229,10 @@ extension ProtobufTestMessages_Proto2_ForeignMessageProto2: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._c {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.c }, fieldNumber: 1, isUnset: { $0._c == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_ForeignMessageProto2, rhs: ProtobufTestMessages_Proto2_ForeignMessageProto2) -> Bool {
     if lhs._c != rhs._c {return false}
@@ -3567,31 +3269,15 @@ extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._optionalInt32 {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001)
-    } }()
-    try { if let v = self._optionalString {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1002)
-    } }()
-    try { if let v = self._nestedMessage {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1003)
-    } }()
-    try { if let v = self._optionalGroup {
-      try visitor.visitSingularGroupField(value: v, fieldNumber: 1004)
-    } }()
-    try { if let v = self._optionalBool {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 1006)
-    } }()
-    if !self.repeatedInt32.isEmpty {
-      try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 1011)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalInt32 }, fieldNumber: 1001, isUnset: { $0._optionalInt32 == nil }),
+    .singularString({ $0.optionalString }, fieldNumber: 1002, isUnset: { $0._optionalString == nil }),
+    .singularMessage({ $0.nestedMessage }, fieldNumber: 1003, isUnset: { $0._nestedMessage == nil }),
+    .singularGroup({ $0.optionalGroup }, fieldNumber: 1004, isUnset: { $0._optionalGroup == nil }),
+    .singularBool({ $0.optionalBool }, fieldNumber: 1006, isUnset: { $0._optionalBool == nil }),
+    .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 1011),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes) -> Bool {
     if lhs._optionalInt32 != rhs._optionalInt32 {return false}
@@ -3623,16 +3309,10 @@ extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -3650,9 +3330,9 @@ extension ProtobufTestMessages_Proto2_NullHypothesisProto2: SwiftProtobuf.Messag
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_NullHypothesisProto2, rhs: ProtobufTestMessages_Proto2_NullHypothesisProto2) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -3669,9 +3349,9 @@ extension ProtobufTestMessages_Proto2_EnumOnlyProto2: SwiftProtobuf.Message, Swi
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_EnumOnlyProto2, rhs: ProtobufTestMessages_Proto2_EnumOnlyProto2) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -3704,16 +3384,10 @@ extension ProtobufTestMessages_Proto2_OneStringProto2: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._data {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularString({ $0.data }, fieldNumber: 1, isUnset: { $0._data == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_OneStringProto2, rhs: ProtobufTestMessages_Proto2_OneStringProto2) -> Bool {
     if lhs._data != rhs._data {return false}
@@ -3744,22 +3418,12 @@ extension ProtobufTestMessages_Proto2_ProtoWithKeywords: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._inline {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._concept {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    } }()
-    if !self.requires.isEmpty {
-      try visitor.visitRepeatedStringField(value: self.requires, fieldNumber: 3)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.inline }, fieldNumber: 1, isUnset: { $0._inline == nil }),
+    .singularString({ $0.concept }, fieldNumber: 2, isUnset: { $0._concept == nil }),
+    .repeatedString({ $0.requires }, fieldNumber: 3),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_ProtoWithKeywords, rhs: ProtobufTestMessages_Proto2_ProtoWithKeywords) -> Bool {
     if lhs._inline != rhs._inline {return false}
@@ -4013,133 +3677,49 @@ extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._requiredInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._requiredInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._requiredUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._requiredUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._requiredSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._requiredSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._requiredFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._requiredFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._requiredSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._requiredSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._requiredFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._requiredDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._requiredBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._requiredString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._requiredBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._requiredNestedMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._requiredForeignMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 19)
-      } }()
-      try { if let v = _storage._requiredNestedEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 21)
-      } }()
-      try { if let v = _storage._requiredForeignEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 22)
-      } }()
-      try { if let v = _storage._requiredStringPiece {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 24)
-      } }()
-      try { if let v = _storage._requiredCord {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 25)
-      } }()
-      try { if let v = _storage._recursiveMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 27)
-      } }()
-      try { if let v = _storage._optionalRecursiveMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 28)
-      } }()
-      try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201)
-      try { if let v = _storage._data {
-        try visitor.visitSingularGroupField(value: v, fieldNumber: 201)
-      } }()
-      try { if let v = _storage._defaultInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 241)
-      } }()
-      try { if let v = _storage._defaultInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 242)
-      } }()
-      try { if let v = _storage._defaultUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243)
-      } }()
-      try { if let v = _storage._defaultUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244)
-      } }()
-      try { if let v = _storage._defaultSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245)
-      } }()
-      try { if let v = _storage._defaultSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246)
-      } }()
-      try { if let v = _storage._defaultFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247)
-      } }()
-      try { if let v = _storage._defaultFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248)
-      } }()
-      try { if let v = _storage._defaultSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249)
-      } }()
-      try { if let v = _storage._defaultSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250)
-      } }()
-      try { if let v = _storage._defaultFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 251)
-      } }()
-      try { if let v = _storage._defaultDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 252)
-      } }()
-      try { if let v = _storage._defaultBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 253)
-      } }()
-      try { if let v = _storage._defaultString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 254)
-      } }()
-      try { if let v = _storage._defaultBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 255)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.requiredInt32 }, fieldNumber: 1, isUnset: { $0._storage._requiredInt32 == nil }),
+    .singularInt64({ $0.requiredInt64 }, fieldNumber: 2, isUnset: { $0._storage._requiredInt64 == nil }),
+    .singularUInt32({ $0.requiredUint32 }, fieldNumber: 3, isUnset: { $0._storage._requiredUint32 == nil }),
+    .singularUInt64({ $0.requiredUint64 }, fieldNumber: 4, isUnset: { $0._storage._requiredUint64 == nil }),
+    .singularSInt32({ $0.requiredSint32 }, fieldNumber: 5, isUnset: { $0._storage._requiredSint32 == nil }),
+    .singularSInt64({ $0.requiredSint64 }, fieldNumber: 6, isUnset: { $0._storage._requiredSint64 == nil }),
+    .singularFixed32({ $0.requiredFixed32 }, fieldNumber: 7, isUnset: { $0._storage._requiredFixed32 == nil }),
+    .singularFixed64({ $0.requiredFixed64 }, fieldNumber: 8, isUnset: { $0._storage._requiredFixed64 == nil }),
+    .singularSFixed32({ $0.requiredSfixed32 }, fieldNumber: 9, isUnset: { $0._storage._requiredSfixed32 == nil }),
+    .singularSFixed64({ $0.requiredSfixed64 }, fieldNumber: 10, isUnset: { $0._storage._requiredSfixed64 == nil }),
+    .singularFloat({ $0.requiredFloat }, fieldNumber: 11, isUnset: { $0._storage._requiredFloat == nil }),
+    .singularDouble({ $0.requiredDouble }, fieldNumber: 12, isUnset: { $0._storage._requiredDouble == nil }),
+    .singularBool({ $0.requiredBool }, fieldNumber: 13, isUnset: { $0._storage._requiredBool == nil }),
+    .singularString({ $0.requiredString }, fieldNumber: 14, isUnset: { $0._storage._requiredString == nil }),
+    .singularBytes({ $0.requiredBytes }, fieldNumber: 15, isUnset: { $0._storage._requiredBytes == nil }),
+    .singularMessage({ $0.requiredNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._requiredNestedMessage == nil }),
+    .singularMessage({ $0.requiredForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._requiredForeignMessage == nil }),
+    .singularEnum({ $0.requiredNestedEnum }, fieldNumber: 21, isUnset: { $0._storage._requiredNestedEnum == nil }),
+    .singularEnum({ $0.requiredForeignEnum }, fieldNumber: 22, isUnset: { $0._storage._requiredForeignEnum == nil }),
+    .singularString({ $0.requiredStringPiece }, fieldNumber: 24, isUnset: { $0._storage._requiredStringPiece == nil }),
+    .singularString({ $0.requiredCord }, fieldNumber: 25, isUnset: { $0._storage._requiredCord == nil }),
+    .singularMessage({ $0.recursiveMessage }, fieldNumber: 27, isUnset: { $0._storage._recursiveMessage == nil }),
+    .singularMessage({ $0.optionalRecursiveMessage }, fieldNumber: 28, isUnset: { $0._storage._optionalRecursiveMessage == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 120, end: 201),
+    .singularGroup({ $0.data }, fieldNumber: 201, isUnset: { $0._storage._data == nil }),
+    .singularInt32({ $0.defaultInt32 }, fieldNumber: 241, isUnset: { $0._storage._defaultInt32 == nil }),
+    .singularInt64({ $0.defaultInt64 }, fieldNumber: 242, isUnset: { $0._storage._defaultInt64 == nil }),
+    .singularUInt32({ $0.defaultUint32 }, fieldNumber: 243, isUnset: { $0._storage._defaultUint32 == nil }),
+    .singularUInt64({ $0.defaultUint64 }, fieldNumber: 244, isUnset: { $0._storage._defaultUint64 == nil }),
+    .singularSInt32({ $0.defaultSint32 }, fieldNumber: 245, isUnset: { $0._storage._defaultSint32 == nil }),
+    .singularSInt64({ $0.defaultSint64 }, fieldNumber: 246, isUnset: { $0._storage._defaultSint64 == nil }),
+    .singularFixed32({ $0.defaultFixed32 }, fieldNumber: 247, isUnset: { $0._storage._defaultFixed32 == nil }),
+    .singularFixed64({ $0.defaultFixed64 }, fieldNumber: 248, isUnset: { $0._storage._defaultFixed64 == nil }),
+    .singularSFixed32({ $0.defaultSfixed32 }, fieldNumber: 249, isUnset: { $0._storage._defaultSfixed32 == nil }),
+    .singularSFixed64({ $0.defaultSfixed64 }, fieldNumber: 250, isUnset: { $0._storage._defaultSfixed64 == nil }),
+    .singularFloat({ $0.defaultFloat }, fieldNumber: 251, isUnset: { $0._storage._defaultFloat == nil }),
+    .singularDouble({ $0.defaultDouble }, fieldNumber: 252, isUnset: { $0._storage._defaultDouble == nil }),
+    .singularBool({ $0.defaultBool }, fieldNumber: 253, isUnset: { $0._storage._defaultBool == nil }),
+    .singularString({ $0.defaultString }, fieldNumber: 254, isUnset: { $0._storage._defaultString == nil }),
+    .singularBytes({ $0.defaultBytes }, fieldNumber: 255, isUnset: { $0._storage._defaultBytes == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -4262,24 +3842,12 @@ extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._a {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._corecursive {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._optionalCorecursive {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._storage._a == nil }),
+    .singularMessage({ $0.corecursive }, fieldNumber: 2, isUnset: { $0._storage._corecursive == nil }),
+    .singularMessage({ $0.optionalCorecursive }, fieldNumber: 3, isUnset: { $0._storage._optionalCorecursive == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -4324,19 +3892,11 @@ extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupInt32 {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 202)
-    } }()
-    try { if let v = self._groupUint32 {
-      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupInt32 }, fieldNumber: 202, isUnset: { $0._groupInt32 == nil }),
+    .singularUInt32({ $0.groupUint32 }, fieldNumber: 203, isUnset: { $0._groupUint32 == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage) -> Bool {
     if lhs._groupInt32 != rhs._groupInt32 {return false}
@@ -4359,10 +3919,10 @@ extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorre
     try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect.self)
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFieldsAsMessageSet({ $0._protobuf_extensionFieldValues }, start: 4, end: 2147483647),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -4394,16 +3954,10 @@ extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorre
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._str {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 25)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularString({ $0.str }, fieldNumber: 25, isUnset: { $0._str == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1) -> Bool {
     if lhs._str != rhs._str {return false}
@@ -4435,16 +3989,10 @@ extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorre
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._i {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 9)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.i }, fieldNumber: 9, isUnset: { $0._i == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2) -> Bool {
     if lhs._i != rhs._i {return false}
diff --git a/Sources/Conformance/test_messages_proto3.pb.swift b/Sources/Conformance/test_messages_proto3.pb.swift
index 619e1523e..e571c765e 100644
--- a/Sources/Conformance/test_messages_proto3.pb.swift
+++ b/Sources/Conformance/test_messages_proto3.pb.swift
@@ -1859,481 +1859,184 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      if _storage._optionalInt32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1)
-      }
-      if _storage._optionalInt64 != 0 {
-        try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2)
-      }
-      if _storage._optionalUint32 != 0 {
-        try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3)
-      }
-      if _storage._optionalUint64 != 0 {
-        try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4)
-      }
-      if _storage._optionalSint32 != 0 {
-        try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5)
-      }
-      if _storage._optionalSint64 != 0 {
-        try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6)
-      }
-      if _storage._optionalFixed32 != 0 {
-        try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7)
-      }
-      if _storage._optionalFixed64 != 0 {
-        try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8)
-      }
-      if _storage._optionalSfixed32 != 0 {
-        try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9)
-      }
-      if _storage._optionalSfixed64 != 0 {
-        try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10)
-      }
-      if _storage._optionalFloat != 0 {
-        try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11)
-      }
-      if _storage._optionalDouble != 0 {
-        try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12)
-      }
-      if _storage._optionalBool != false {
-        try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13)
-      }
-      if !_storage._optionalString.isEmpty {
-        try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14)
-      }
-      if !_storage._optionalBytes.isEmpty {
-        try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15)
-      }
-      try { if let v = _storage._optionalNestedMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._optionalForeignMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 19)
-      } }()
-      if _storage._optionalNestedEnum != .foo {
-        try visitor.visitSingularEnumField(value: _storage._optionalNestedEnum, fieldNumber: 21)
-      }
-      if _storage._optionalForeignEnum != .foreignFoo {
-        try visitor.visitSingularEnumField(value: _storage._optionalForeignEnum, fieldNumber: 22)
-      }
-      if _storage._optionalAliasedEnum != .aliasFoo {
-        try visitor.visitSingularEnumField(value: _storage._optionalAliasedEnum, fieldNumber: 23)
-      }
-      if !_storage._optionalStringPiece.isEmpty {
-        try visitor.visitSingularStringField(value: _storage._optionalStringPiece, fieldNumber: 24)
-      }
-      if !_storage._optionalCord.isEmpty {
-        try visitor.visitSingularStringField(value: _storage._optionalCord, fieldNumber: 25)
-      }
-      try { if let v = _storage._recursiveMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 27)
-      } }()
-      if !_storage._repeatedInt32.isEmpty {
-        try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31)
-      }
-      if !_storage._repeatedInt64.isEmpty {
-        try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32)
-      }
-      if !_storage._repeatedUint32.isEmpty {
-        try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33)
-      }
-      if !_storage._repeatedUint64.isEmpty {
-        try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34)
-      }
-      if !_storage._repeatedSint32.isEmpty {
-        try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35)
-      }
-      if !_storage._repeatedSint64.isEmpty {
-        try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36)
-      }
-      if !_storage._repeatedFixed32.isEmpty {
-        try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37)
-      }
-      if !_storage._repeatedFixed64.isEmpty {
-        try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38)
-      }
-      if !_storage._repeatedSfixed32.isEmpty {
-        try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39)
-      }
-      if !_storage._repeatedSfixed64.isEmpty {
-        try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40)
-      }
-      if !_storage._repeatedFloat.isEmpty {
-        try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41)
-      }
-      if !_storage._repeatedDouble.isEmpty {
-        try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42)
-      }
-      if !_storage._repeatedBool.isEmpty {
-        try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43)
-      }
-      if !_storage._repeatedString.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44)
-      }
-      if !_storage._repeatedBytes.isEmpty {
-        try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45)
-      }
-      if !_storage._repeatedNestedMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48)
-      }
-      if !_storage._repeatedForeignMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49)
-      }
-      if !_storage._repeatedNestedEnum.isEmpty {
-        try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51)
-      }
-      if !_storage._repeatedForeignEnum.isEmpty {
-        try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52)
-      }
-      if !_storage._repeatedStringPiece.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54)
-      }
-      if !_storage._repeatedCord.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55)
-      }
-      if !_storage._mapInt32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapInt32Int32, fieldNumber: 56)
-      }
-      if !_storage._mapInt64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapInt64Int64, fieldNumber: 57)
-      }
-      if !_storage._mapUint32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapUint32Uint32, fieldNumber: 58)
-      }
-      if !_storage._mapUint64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapUint64Uint64, fieldNumber: 59)
-      }
-      if !_storage._mapSint32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSint32Sint32, fieldNumber: 60)
-      }
-      if !_storage._mapSint64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSint64Sint64, fieldNumber: 61)
-      }
-      if !_storage._mapFixed32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62)
-      }
-      if !_storage._mapFixed64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63)
-      }
-      if !_storage._mapSfixed32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64)
-      }
-      if !_storage._mapSfixed64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65)
-      }
-      if !_storage._mapInt32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapInt32Float, fieldNumber: 66)
-      }
-      if !_storage._mapInt32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapInt32Double, fieldNumber: 67)
-      }
-      if !_storage._mapBoolBool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapBoolBool, fieldNumber: 68)
-      }
-      if !_storage._mapStringString.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, value: _storage._mapStringString, fieldNumber: 69)
-      }
-      if !_storage._mapStringBytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapStringBytes, fieldNumber: 70)
-      }
-      if !_storage._mapStringNestedMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage>.self, value: _storage._mapStringNestedMessage, fieldNumber: 71)
-      }
-      if !_storage._mapStringForeignMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_ForeignMessage>.self, value: _storage._mapStringForeignMessage, fieldNumber: 72)
-      }
-      if !_storage._mapStringNestedEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum>.self, value: _storage._mapStringNestedEnum, fieldNumber: 73)
-      }
-      if !_storage._mapStringForeignEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_ForeignEnum>.self, value: _storage._mapStringForeignEnum, fieldNumber: 74)
-      }
-      if !_storage._packedInt32.isEmpty {
-        try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75)
-      }
-      if !_storage._packedInt64.isEmpty {
-        try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76)
-      }
-      if !_storage._packedUint32.isEmpty {
-        try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77)
-      }
-      if !_storage._packedUint64.isEmpty {
-        try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78)
-      }
-      if !_storage._packedSint32.isEmpty {
-        try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79)
-      }
-      if !_storage._packedSint64.isEmpty {
-        try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80)
-      }
-      if !_storage._packedFixed32.isEmpty {
-        try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81)
-      }
-      if !_storage._packedFixed64.isEmpty {
-        try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82)
-      }
-      if !_storage._packedSfixed32.isEmpty {
-        try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83)
-      }
-      if !_storage._packedSfixed64.isEmpty {
-        try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84)
-      }
-      if !_storage._packedFloat.isEmpty {
-        try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85)
-      }
-      if !_storage._packedDouble.isEmpty {
-        try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86)
-      }
-      if !_storage._packedBool.isEmpty {
-        try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87)
-      }
-      if !_storage._packedNestedEnum.isEmpty {
-        try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88)
-      }
-      if !_storage._unpackedInt32.isEmpty {
-        try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89)
-      }
-      if !_storage._unpackedInt64.isEmpty {
-        try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90)
-      }
-      if !_storage._unpackedUint32.isEmpty {
-        try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91)
-      }
-      if !_storage._unpackedUint64.isEmpty {
-        try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92)
-      }
-      if !_storage._unpackedSint32.isEmpty {
-        try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93)
-      }
-      if !_storage._unpackedSint64.isEmpty {
-        try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94)
-      }
-      if !_storage._unpackedFixed32.isEmpty {
-        try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95)
-      }
-      if !_storage._unpackedFixed64.isEmpty {
-        try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96)
-      }
-      if !_storage._unpackedSfixed32.isEmpty {
-        try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97)
-      }
-      if !_storage._unpackedSfixed64.isEmpty {
-        try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98)
-      }
-      if !_storage._unpackedFloat.isEmpty {
-        try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99)
-      }
-      if !_storage._unpackedDouble.isEmpty {
-        try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100)
-      }
-      if !_storage._unpackedBool.isEmpty {
-        try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101)
-      }
-      if !_storage._unpackedNestedEnum.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102)
-      }
-      switch _storage._oneofField {
-      case .oneofUint32?: try {
-        guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111)
-      }()
-      case .oneofNestedMessage?: try {
-        guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 112)
-      }()
-      case .oneofString?: try {
-        guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularStringField(value: v, fieldNumber: 113)
-      }()
-      case .oneofBytes?: try {
-        guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 114)
-      }()
-      case .oneofBool?: try {
-        guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 115)
-      }()
-      case .oneofUint64?: try {
-        guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116)
-      }()
-      case .oneofFloat?: try {
-        guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 117)
-      }()
-      case .oneofDouble?: try {
-        guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 118)
-      }()
-      case .oneofEnum?: try {
-        guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 119)
-      }()
-      case .oneofNullValue?: try {
-        guard case .oneofNullValue(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 120)
-      }()
-      case nil: break
-      }
-      try { if let v = _storage._optionalBoolWrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 201)
-      } }()
-      try { if let v = _storage._optionalInt32Wrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 202)
-      } }()
-      try { if let v = _storage._optionalInt64Wrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 203)
-      } }()
-      try { if let v = _storage._optionalUint32Wrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 204)
-      } }()
-      try { if let v = _storage._optionalUint64Wrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 205)
-      } }()
-      try { if let v = _storage._optionalFloatWrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 206)
-      } }()
-      try { if let v = _storage._optionalDoubleWrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 207)
-      } }()
-      try { if let v = _storage._optionalStringWrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 208)
-      } }()
-      try { if let v = _storage._optionalBytesWrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 209)
-      } }()
-      if !_storage._repeatedBoolWrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedBoolWrapper, fieldNumber: 211)
-      }
-      if !_storage._repeatedInt32Wrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedInt32Wrapper, fieldNumber: 212)
-      }
-      if !_storage._repeatedInt64Wrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedInt64Wrapper, fieldNumber: 213)
-      }
-      if !_storage._repeatedUint32Wrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedUint32Wrapper, fieldNumber: 214)
-      }
-      if !_storage._repeatedUint64Wrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedUint64Wrapper, fieldNumber: 215)
-      }
-      if !_storage._repeatedFloatWrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedFloatWrapper, fieldNumber: 216)
-      }
-      if !_storage._repeatedDoubleWrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedDoubleWrapper, fieldNumber: 217)
-      }
-      if !_storage._repeatedStringWrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedStringWrapper, fieldNumber: 218)
-      }
-      if !_storage._repeatedBytesWrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedBytesWrapper, fieldNumber: 219)
-      }
-      try { if let v = _storage._optionalDuration {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 301)
-      } }()
-      try { if let v = _storage._optionalTimestamp {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 302)
-      } }()
-      try { if let v = _storage._optionalFieldMask {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 303)
-      } }()
-      try { if let v = _storage._optionalStruct {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 304)
-      } }()
-      try { if let v = _storage._optionalAny {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 305)
-      } }()
-      try { if let v = _storage._optionalValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 306)
-      } }()
-      if _storage._optionalNullValue != .nullValue {
-        try visitor.visitSingularEnumField(value: _storage._optionalNullValue, fieldNumber: 307)
-      }
-      if !_storage._repeatedDuration.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedDuration, fieldNumber: 311)
-      }
-      if !_storage._repeatedTimestamp.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedTimestamp, fieldNumber: 312)
-      }
-      if !_storage._repeatedFieldmask.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedFieldmask, fieldNumber: 313)
-      }
-      if !_storage._repeatedAny.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedAny, fieldNumber: 315)
-      }
-      if !_storage._repeatedValue.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedValue, fieldNumber: 316)
-      }
-      if !_storage._repeatedListValue.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedListValue, fieldNumber: 317)
-      }
-      if !_storage._repeatedStruct.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedStruct, fieldNumber: 324)
-      }
-      if _storage._fieldname1 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldname1, fieldNumber: 401)
-      }
-      if _storage._fieldName2 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName2, fieldNumber: 402)
-      }
-      if _storage._fieldName3 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName3, fieldNumber: 403)
-      }
-      if _storage._field_Name4_ != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field_Name4_, fieldNumber: 404)
-      }
-      if _storage._field0Name5 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field0Name5, fieldNumber: 405)
-      }
-      if _storage._field0Name6 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field0Name6, fieldNumber: 406)
-      }
-      if _storage._fieldName7 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName7, fieldNumber: 407)
-      }
-      if _storage._fieldName8 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName8, fieldNumber: 408)
-      }
-      if _storage._fieldName9 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName9, fieldNumber: 409)
-      }
-      if _storage._fieldName10 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName10, fieldNumber: 410)
-      }
-      if _storage._fieldName11 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName11, fieldNumber: 411)
-      }
-      if _storage._fieldName12 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName12, fieldNumber: 412)
-      }
-      if _storage.__FieldName13 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage.__FieldName13, fieldNumber: 413)
-      }
-      if _storage.__FieldName14 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage.__FieldName14, fieldNumber: 414)
-      }
-      if _storage._field_Name15 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field_Name15, fieldNumber: 415)
-      }
-      if _storage._field_Name16 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field_Name16, fieldNumber: 416)
-      }
-      if _storage._fieldName17__ != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName17__, fieldNumber: 417)
-      }
-      if _storage._fieldName18__ != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName18__, fieldNumber: 418)
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalInt32 }, fieldNumber: 1),
+    .singularInt64({ $0.optionalInt64 }, fieldNumber: 2),
+    .singularUInt32({ $0.optionalUint32 }, fieldNumber: 3),
+    .singularUInt64({ $0.optionalUint64 }, fieldNumber: 4),
+    .singularSInt32({ $0.optionalSint32 }, fieldNumber: 5),
+    .singularSInt64({ $0.optionalSint64 }, fieldNumber: 6),
+    .singularFixed32({ $0.optionalFixed32 }, fieldNumber: 7),
+    .singularFixed64({ $0.optionalFixed64 }, fieldNumber: 8),
+    .singularSFixed32({ $0.optionalSfixed32 }, fieldNumber: 9),
+    .singularSFixed64({ $0.optionalSfixed64 }, fieldNumber: 10),
+    .singularFloat({ $0.optionalFloat }, fieldNumber: 11),
+    .singularDouble({ $0.optionalDouble }, fieldNumber: 12),
+    .singularBool({ $0.optionalBool }, fieldNumber: 13),
+    .singularString({ $0.optionalString }, fieldNumber: 14),
+    .singularBytes({ $0.optionalBytes }, fieldNumber: 15),
+    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
+    .singularMessage({ $0.optionalForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._optionalForeignMessage == nil }),
+    .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, defaultValue: .foo),
+    .singularEnum({ $0.optionalForeignEnum }, fieldNumber: 22, defaultValue: .foreignFoo),
+    .singularEnum({ $0.optionalAliasedEnum }, fieldNumber: 23, defaultValue: .aliasFoo),
+    .singularString({ $0.optionalStringPiece }, fieldNumber: 24),
+    .singularString({ $0.optionalCord }, fieldNumber: 25),
+    .singularMessage({ $0.recursiveMessage }, fieldNumber: 27, isUnset: { $0._storage._recursiveMessage == nil }),
+    .packedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
+    .packedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
+    .packedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
+    .packedUInt64({ $0.repeatedUint64 }, fieldNumber: 34),
+    .packedSInt32({ $0.repeatedSint32 }, fieldNumber: 35),
+    .packedSInt64({ $0.repeatedSint64 }, fieldNumber: 36),
+    .packedFixed32({ $0.repeatedFixed32 }, fieldNumber: 37),
+    .packedFixed64({ $0.repeatedFixed64 }, fieldNumber: 38),
+    .packedSFixed32({ $0.repeatedSfixed32 }, fieldNumber: 39),
+    .packedSFixed64({ $0.repeatedSfixed64 }, fieldNumber: 40),
+    .packedFloat({ $0.repeatedFloat }, fieldNumber: 41),
+    .packedDouble({ $0.repeatedDouble }, fieldNumber: 42),
+    .packedBool({ $0.repeatedBool }, fieldNumber: 43),
+    .repeatedString({ $0.repeatedString }, fieldNumber: 44),
+    .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
+    .repeatedMessage({ $0.repeatedNestedMessage }, fieldNumber: 48),
+    .repeatedMessage({ $0.repeatedForeignMessage }, fieldNumber: 49),
+    .packedEnum({ $0.repeatedNestedEnum }, fieldNumber: 51),
+    .packedEnum({ $0.repeatedForeignEnum }, fieldNumber: 52),
+    .repeatedString({ $0.repeatedStringPiece }, fieldNumber: 54),
+    .repeatedString({ $0.repeatedCord }, fieldNumber: 55),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 56),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 57),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 58),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 59),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 60),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 61),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 62),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 63),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 64),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 65),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 66),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 67),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 68),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 69),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0.mapStringBytes }, fieldNumber: 70),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage>.self, { $0.mapStringNestedMessage }, fieldNumber: 71),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_ForeignMessage>.self, { $0.mapStringForeignMessage }, fieldNumber: 72),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum>.self, { $0.mapStringNestedEnum }, fieldNumber: 73),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_ForeignEnum>.self, { $0.mapStringForeignEnum }, fieldNumber: 74),
+    .packedInt32({ $0.packedInt32 }, fieldNumber: 75),
+    .packedInt64({ $0.packedInt64 }, fieldNumber: 76),
+    .packedUInt32({ $0.packedUint32 }, fieldNumber: 77),
+    .packedUInt64({ $0.packedUint64 }, fieldNumber: 78),
+    .packedSInt32({ $0.packedSint32 }, fieldNumber: 79),
+    .packedSInt64({ $0.packedSint64 }, fieldNumber: 80),
+    .packedFixed32({ $0.packedFixed32 }, fieldNumber: 81),
+    .packedFixed64({ $0.packedFixed64 }, fieldNumber: 82),
+    .packedSFixed32({ $0.packedSfixed32 }, fieldNumber: 83),
+    .packedSFixed64({ $0.packedSfixed64 }, fieldNumber: 84),
+    .packedFloat({ $0.packedFloat }, fieldNumber: 85),
+    .packedDouble({ $0.packedDouble }, fieldNumber: 86),
+    .packedBool({ $0.packedBool }, fieldNumber: 87),
+    .packedEnum({ $0.packedNestedEnum }, fieldNumber: 88),
+    .repeatedInt32({ $0.unpackedInt32 }, fieldNumber: 89),
+    .repeatedInt64({ $0.unpackedInt64 }, fieldNumber: 90),
+    .repeatedUInt32({ $0.unpackedUint32 }, fieldNumber: 91),
+    .repeatedUInt64({ $0.unpackedUint64 }, fieldNumber: 92),
+    .repeatedSInt32({ $0.unpackedSint32 }, fieldNumber: 93),
+    .repeatedSInt64({ $0.unpackedSint64 }, fieldNumber: 94),
+    .repeatedFixed32({ $0.unpackedFixed32 }, fieldNumber: 95),
+    .repeatedFixed64({ $0.unpackedFixed64 }, fieldNumber: 96),
+    .repeatedSFixed32({ $0.unpackedSfixed32 }, fieldNumber: 97),
+    .repeatedSFixed64({ $0.unpackedSfixed64 }, fieldNumber: 98),
+    .repeatedFloat({ $0.unpackedFloat }, fieldNumber: 99),
+    .repeatedDouble({ $0.unpackedDouble }, fieldNumber: 100),
+    .repeatedBool({ $0.unpackedBool }, fieldNumber: 101),
+    .repeatedEnum({ $0.unpackedNestedEnum }, fieldNumber: 102),
+    .oneOf({ $0.oneofField }) {
+      switch $0 {
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofNestedMessage:
+        return _oneOfField_oneofNestedMessage
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
+      case .oneofBool:
+        return _oneOfField_oneofBool
+      case .oneofUint64:
+        return _oneOfField_oneofUint64
+      case .oneofFloat:
+        return _oneOfField_oneofFloat
+      case .oneofDouble:
+        return _oneOfField_oneofDouble
+      case .oneofEnum:
+        return _oneOfField_oneofEnum
+      case .oneofNullValue:
+        return _oneOfField_oneofNullValue
+      }
+    },
+    .singularMessage({ $0.optionalBoolWrapper }, fieldNumber: 201, isUnset: { $0._storage._optionalBoolWrapper == nil }),
+    .singularMessage({ $0.optionalInt32Wrapper }, fieldNumber: 202, isUnset: { $0._storage._optionalInt32Wrapper == nil }),
+    .singularMessage({ $0.optionalInt64Wrapper }, fieldNumber: 203, isUnset: { $0._storage._optionalInt64Wrapper == nil }),
+    .singularMessage({ $0.optionalUint32Wrapper }, fieldNumber: 204, isUnset: { $0._storage._optionalUint32Wrapper == nil }),
+    .singularMessage({ $0.optionalUint64Wrapper }, fieldNumber: 205, isUnset: { $0._storage._optionalUint64Wrapper == nil }),
+    .singularMessage({ $0.optionalFloatWrapper }, fieldNumber: 206, isUnset: { $0._storage._optionalFloatWrapper == nil }),
+    .singularMessage({ $0.optionalDoubleWrapper }, fieldNumber: 207, isUnset: { $0._storage._optionalDoubleWrapper == nil }),
+    .singularMessage({ $0.optionalStringWrapper }, fieldNumber: 208, isUnset: { $0._storage._optionalStringWrapper == nil }),
+    .singularMessage({ $0.optionalBytesWrapper }, fieldNumber: 209, isUnset: { $0._storage._optionalBytesWrapper == nil }),
+    .repeatedMessage({ $0.repeatedBoolWrapper }, fieldNumber: 211),
+    .repeatedMessage({ $0.repeatedInt32Wrapper }, fieldNumber: 212),
+    .repeatedMessage({ $0.repeatedInt64Wrapper }, fieldNumber: 213),
+    .repeatedMessage({ $0.repeatedUint32Wrapper }, fieldNumber: 214),
+    .repeatedMessage({ $0.repeatedUint64Wrapper }, fieldNumber: 215),
+    .repeatedMessage({ $0.repeatedFloatWrapper }, fieldNumber: 216),
+    .repeatedMessage({ $0.repeatedDoubleWrapper }, fieldNumber: 217),
+    .repeatedMessage({ $0.repeatedStringWrapper }, fieldNumber: 218),
+    .repeatedMessage({ $0.repeatedBytesWrapper }, fieldNumber: 219),
+    .singularMessage({ $0.optionalDuration }, fieldNumber: 301, isUnset: { $0._storage._optionalDuration == nil }),
+    .singularMessage({ $0.optionalTimestamp }, fieldNumber: 302, isUnset: { $0._storage._optionalTimestamp == nil }),
+    .singularMessage({ $0.optionalFieldMask }, fieldNumber: 303, isUnset: { $0._storage._optionalFieldMask == nil }),
+    .singularMessage({ $0.optionalStruct }, fieldNumber: 304, isUnset: { $0._storage._optionalStruct == nil }),
+    .singularMessage({ $0.optionalAny }, fieldNumber: 305, isUnset: { $0._storage._optionalAny == nil }),
+    .singularMessage({ $0.optionalValue }, fieldNumber: 306, isUnset: { $0._storage._optionalValue == nil }),
+    .singularEnum({ $0.optionalNullValue }, fieldNumber: 307, defaultValue: .nullValue),
+    .repeatedMessage({ $0.repeatedDuration }, fieldNumber: 311),
+    .repeatedMessage({ $0.repeatedTimestamp }, fieldNumber: 312),
+    .repeatedMessage({ $0.repeatedFieldmask }, fieldNumber: 313),
+    .repeatedMessage({ $0.repeatedAny }, fieldNumber: 315),
+    .repeatedMessage({ $0.repeatedValue }, fieldNumber: 316),
+    .repeatedMessage({ $0.repeatedListValue }, fieldNumber: 317),
+    .repeatedMessage({ $0.repeatedStruct }, fieldNumber: 324),
+    .singularInt32({ $0.fieldname1 }, fieldNumber: 401),
+    .singularInt32({ $0.fieldName2 }, fieldNumber: 402),
+    .singularInt32({ $0.fieldName3 }, fieldNumber: 403),
+    .singularInt32({ $0.field_Name4_ }, fieldNumber: 404),
+    .singularInt32({ $0.field0Name5 }, fieldNumber: 405),
+    .singularInt32({ $0.field0Name6 }, fieldNumber: 406),
+    .singularInt32({ $0.fieldName7 }, fieldNumber: 407),
+    .singularInt32({ $0.fieldName8 }, fieldNumber: 408),
+    .singularInt32({ $0.fieldName9 }, fieldNumber: 409),
+    .singularInt32({ $0.fieldName10 }, fieldNumber: 410),
+    .singularInt32({ $0.fieldName11 }, fieldNumber: 411),
+    .singularInt32({ $0.fieldName12 }, fieldNumber: 412),
+    .singularInt32({ $0._FieldName13 }, fieldNumber: 413),
+    .singularInt32({ $0._FieldName14 }, fieldNumber: 414),
+    .singularInt32({ $0.field_Name15 }, fieldNumber: 415),
+    .singularInt32({ $0.field_Name16 }, fieldNumber: 416),
+    .singularInt32({ $0.fieldName17__ }, fieldNumber: 417),
+    .singularInt32({ $0.fieldName18__ }, fieldNumber: 418),
+  ]
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
+  private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 115, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint64: Field<Self> = .singularUInt64({ $0.oneofUint64 }, fieldNumber: 116, isUnset: { _ in false })
+  private static let _oneOfField_oneofFloat: Field<Self> = .singularFloat({ $0.oneofFloat }, fieldNumber: 117, isUnset: { _ in false })
+  private static let _oneOfField_oneofDouble: Field<Self> = .singularDouble({ $0.oneofDouble }, fieldNumber: 118, isUnset: { _ in false })
+  private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 119, isUnset: { _ in false })
+  private static let _oneOfField_oneofNullValue: Field<Self> = .singularEnum({ $0.oneofNullValue }, fieldNumber: 120, isUnset: { _ in false })
+
 
   static func ==(lhs: ProtobufTestMessages_Proto3_TestAllTypesProto3, rhs: ProtobufTestMessages_Proto3_TestAllTypesProto3) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -2552,21 +2255,11 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      if _storage._a != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._a, fieldNumber: 1)
-      }
-      try { if let v = _storage._corecursive {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1),
+    .singularMessage({ $0.corecursive }, fieldNumber: 2, isUnset: { $0._storage._corecursive == nil }),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage, rhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -2602,12 +2295,10 @@ extension ProtobufTestMessages_Proto3_ForeignMessage: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.c != 0 {
-      try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.c }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto3_ForeignMessage, rhs: ProtobufTestMessages_Proto3_ForeignMessage) -> Bool {
     if lhs.c != rhs.c {return false}
@@ -2625,9 +2316,9 @@ extension ProtobufTestMessages_Proto3_NullHypothesisProto3: SwiftProtobuf.Messag
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto3_NullHypothesisProto3, rhs: ProtobufTestMessages_Proto3_NullHypothesisProto3) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -2644,9 +2335,9 @@ extension ProtobufTestMessages_Proto3_EnumOnlyProto3: SwiftProtobuf.Message, Swi
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: ProtobufTestMessages_Proto3_EnumOnlyProto3, rhs: ProtobufTestMessages_Proto3_EnumOnlyProto3) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
diff --git a/Sources/SwiftProtobuf/any.pb.swift b/Sources/SwiftProtobuf/any.pb.swift
index 5a6ad3854..341d72e1d 100644
--- a/Sources/SwiftProtobuf/any.pb.swift
+++ b/Sources/SwiftProtobuf/any.pb.swift
@@ -221,15 +221,15 @@ extension Google_Protobuf_Any: Message, _MessageImplementationBase, _ProtoNamePr
     }
   }
 
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.typeURL }, fieldNumber: 1),
+    .singularBytes({ $0.value }, fieldNumber: 2),
+  ]
+
   public func traverse<V: Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      try _storage.preTraverse()
-      if !_storage._typeURL.isEmpty {
-        try visitor.visitSingularStringField(value: _storage._typeURL, fieldNumber: 1)
-      }
-      if !_storage._value.isEmpty {
-        try visitor.visitSingularBytesField(value: _storage._value, fieldNumber: 2)
-      }
+    try _storage.preTraverse()
+    for field in Self._fields {
+      try field.traverse(message: self, visitor: &visitor)
     }
     try unknownFields.traverse(visitor: &visitor)
   }
diff --git a/Sources/SwiftProtobuf/api.pb.swift b/Sources/SwiftProtobuf/api.pb.swift
index e41b0f1ce..cd686b29c 100644
--- a/Sources/SwiftProtobuf/api.pb.swift
+++ b/Sources/SwiftProtobuf/api.pb.swift
@@ -279,34 +279,16 @@ extension Google_Protobuf_Api: Message, _MessageImplementationBase, _ProtoNamePr
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if !self.name.isEmpty {
-      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
-    }
-    if !self.methods.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.methods, fieldNumber: 2)
-    }
-    if !self.options.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 3)
-    }
-    if !self.version.isEmpty {
-      try visitor.visitSingularStringField(value: self.version, fieldNumber: 4)
-    }
-    try { if let v = self._sourceContext {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
-    } }()
-    if !self.mixins.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.mixins, fieldNumber: 6)
-    }
-    if self.syntax != .proto2 {
-      try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 7)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1),
+    .repeatedMessage({ $0.methods }, fieldNumber: 2),
+    .repeatedMessage({ $0.options }, fieldNumber: 3),
+    .singularString({ $0.version }, fieldNumber: 4),
+    .singularMessage({ $0.sourceContext }, fieldNumber: 5, isUnset: { $0._sourceContext == nil }),
+    .repeatedMessage({ $0.mixins }, fieldNumber: 6),
+    .singularEnum({ $0.syntax }, fieldNumber: 7, defaultValue: .proto2),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Api, rhs: Google_Protobuf_Api) -> Bool {
     if lhs.name != rhs.name {return false}
@@ -351,30 +333,16 @@ extension Google_Protobuf_Method: Message, _MessageImplementationBase, _ProtoNam
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.name.isEmpty {
-      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
-    }
-    if !self.requestTypeURL.isEmpty {
-      try visitor.visitSingularStringField(value: self.requestTypeURL, fieldNumber: 2)
-    }
-    if self.requestStreaming != false {
-      try visitor.visitSingularBoolField(value: self.requestStreaming, fieldNumber: 3)
-    }
-    if !self.responseTypeURL.isEmpty {
-      try visitor.visitSingularStringField(value: self.responseTypeURL, fieldNumber: 4)
-    }
-    if self.responseStreaming != false {
-      try visitor.visitSingularBoolField(value: self.responseStreaming, fieldNumber: 5)
-    }
-    if !self.options.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 6)
-    }
-    if self.syntax != .proto2 {
-      try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 7)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1),
+    .singularString({ $0.requestTypeURL }, fieldNumber: 2),
+    .singularBool({ $0.requestStreaming }, fieldNumber: 3),
+    .singularString({ $0.responseTypeURL }, fieldNumber: 4),
+    .singularBool({ $0.responseStreaming }, fieldNumber: 5),
+    .repeatedMessage({ $0.options }, fieldNumber: 6),
+    .singularEnum({ $0.syntax }, fieldNumber: 7, defaultValue: .proto2),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Method, rhs: Google_Protobuf_Method) -> Bool {
     if lhs.name != rhs.name {return false}
@@ -409,15 +377,11 @@ extension Google_Protobuf_Mixin: Message, _MessageImplementationBase, _ProtoName
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.name.isEmpty {
-      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
-    }
-    if !self.root.isEmpty {
-      try visitor.visitSingularStringField(value: self.root, fieldNumber: 2)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1),
+    .singularString({ $0.root }, fieldNumber: 2),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Mixin, rhs: Google_Protobuf_Mixin) -> Bool {
     if lhs.name != rhs.name {return false}
diff --git a/Sources/SwiftProtobuf/descriptor.pb.swift b/Sources/SwiftProtobuf/descriptor.pb.swift
index 72ece99b0..926adb1d3 100644
--- a/Sources/SwiftProtobuf/descriptor.pb.swift
+++ b/Sources/SwiftProtobuf/descriptor.pb.swift
@@ -2966,12 +2966,10 @@ extension Google_Protobuf_FileDescriptorSet: Message, _MessageImplementationBase
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.file.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.file, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.file }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FileDescriptorSet, rhs: Google_Protobuf_FileDescriptorSet) -> Bool {
     if lhs.file != rhs.file {return false}
@@ -3031,52 +3029,22 @@ extension Google_Protobuf_FileDescriptorProto: Message, _MessageImplementationBa
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._name {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._package {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    } }()
-    if !self.dependency.isEmpty {
-      try visitor.visitRepeatedStringField(value: self.dependency, fieldNumber: 3)
-    }
-    if !self.messageType.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.messageType, fieldNumber: 4)
-    }
-    if !self.enumType.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.enumType, fieldNumber: 5)
-    }
-    if !self.service.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.service, fieldNumber: 6)
-    }
-    if !self.`extension`.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.`extension`, fieldNumber: 7)
-    }
-    try { if let v = self._options {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
-    } }()
-    try { if let v = self._sourceCodeInfo {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 9)
-    } }()
-    if !self.publicDependency.isEmpty {
-      try visitor.visitRepeatedInt32Field(value: self.publicDependency, fieldNumber: 10)
-    }
-    if !self.weakDependency.isEmpty {
-      try visitor.visitRepeatedInt32Field(value: self.weakDependency, fieldNumber: 11)
-    }
-    try { if let v = self._syntax {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 12)
-    } }()
-    try { if let v = self._edition {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 14)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
+    .singularString({ $0.package }, fieldNumber: 2, isUnset: { $0._package == nil }),
+    .repeatedString({ $0.dependency }, fieldNumber: 3),
+    .repeatedMessage({ $0.messageType }, fieldNumber: 4),
+    .repeatedMessage({ $0.enumType }, fieldNumber: 5),
+    .repeatedMessage({ $0.service }, fieldNumber: 6),
+    .repeatedMessage({ $0.`extension` }, fieldNumber: 7),
+    .singularMessage({ $0.options }, fieldNumber: 8, isUnset: { $0._options == nil }),
+    .singularMessage({ $0.sourceCodeInfo }, fieldNumber: 9, isUnset: { $0._sourceCodeInfo == nil }),
+    .repeatedInt32({ $0.publicDependency }, fieldNumber: 10),
+    .repeatedInt32({ $0.weakDependency }, fieldNumber: 11),
+    .singularString({ $0.syntax }, fieldNumber: 12, isUnset: { $0._syntax == nil }),
+    .singularEnum({ $0.edition }, fieldNumber: 14, isUnset: { $0._edition == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FileDescriptorProto, rhs: Google_Protobuf_FileDescriptorProto) -> Bool {
     if lhs._name != rhs._name {return false}
@@ -3186,45 +3154,19 @@ extension Google_Protobuf_DescriptorProto: Message, _MessageImplementationBase,
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._name {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-      } }()
-      if !_storage._field.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._field, fieldNumber: 2)
-      }
-      if !_storage._nestedType.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._nestedType, fieldNumber: 3)
-      }
-      if !_storage._enumType.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._enumType, fieldNumber: 4)
-      }
-      if !_storage._extensionRange.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._extensionRange, fieldNumber: 5)
-      }
-      if !_storage._extension.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._extension, fieldNumber: 6)
-      }
-      try { if let v = _storage._options {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
-      } }()
-      if !_storage._oneofDecl.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._oneofDecl, fieldNumber: 8)
-      }
-      if !_storage._reservedRange.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._reservedRange, fieldNumber: 9)
-      }
-      if !_storage._reservedName.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._reservedName, fieldNumber: 10)
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._storage._name == nil }),
+    .repeatedMessage({ $0.field }, fieldNumber: 2),
+    .repeatedMessage({ $0.nestedType }, fieldNumber: 3),
+    .repeatedMessage({ $0.enumType }, fieldNumber: 4),
+    .repeatedMessage({ $0.extensionRange }, fieldNumber: 5),
+    .repeatedMessage({ $0.`extension` }, fieldNumber: 6),
+    .singularMessage({ $0.options }, fieldNumber: 7, isUnset: { $0._storage._options == nil }),
+    .repeatedMessage({ $0.oneofDecl }, fieldNumber: 8),
+    .repeatedMessage({ $0.reservedRange }, fieldNumber: 9),
+    .repeatedString({ $0.reservedName }, fieldNumber: 10),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_DescriptorProto, rhs: Google_Protobuf_DescriptorProto) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -3277,22 +3219,12 @@ extension Google_Protobuf_DescriptorProto.ExtensionRange: Message, _MessageImple
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._start {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._end {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._options {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.start }, fieldNumber: 1, isUnset: { $0._start == nil }),
+    .singularInt32({ $0.end }, fieldNumber: 2, isUnset: { $0._end == nil }),
+    .singularMessage({ $0.options }, fieldNumber: 3, isUnset: { $0._options == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_DescriptorProto.ExtensionRange, rhs: Google_Protobuf_DescriptorProto.ExtensionRange) -> Bool {
     if lhs._start != rhs._start {return false}
@@ -3323,19 +3255,11 @@ extension Google_Protobuf_DescriptorProto.ReservedRange: Message, _MessageImplem
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._start {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._end {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.start }, fieldNumber: 1, isUnset: { $0._start == nil }),
+    .singularInt32({ $0.end }, fieldNumber: 2, isUnset: { $0._end == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_DescriptorProto.ReservedRange, rhs: Google_Protobuf_DescriptorProto.ReservedRange) -> Bool {
     if lhs._start != rhs._start {return false}
@@ -3378,26 +3302,14 @@ extension Google_Protobuf_ExtensionRangeOptions: Message, _MessageImplementation
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if !self.declaration.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.declaration, fieldNumber: 2)
-    }
-    try { if let v = self._verification {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._features {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 50)
-    } }()
-    if !self.uninterpretedOption.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999)
-    }
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.declaration }, fieldNumber: 2),
+    .singularEnum({ $0.verification }, fieldNumber: 3, isUnset: { $0._verification == nil }),
+    .singularMessage({ $0.features }, fieldNumber: 50, isUnset: { $0._features == nil }),
+    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_ExtensionRangeOptions, rhs: Google_Protobuf_ExtensionRangeOptions) -> Bool {
     if lhs.uninterpretedOption != rhs.uninterpretedOption {return false}
@@ -3443,28 +3355,14 @@ extension Google_Protobuf_ExtensionRangeOptions.Declaration: Message, _MessageIm
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._number {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._fullName {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._type {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._reserved {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 5)
-    } }()
-    try { if let v = self._repeated {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 6)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.number }, fieldNumber: 1, isUnset: { $0._number == nil }),
+    .singularString({ $0.fullName }, fieldNumber: 2, isUnset: { $0._fullName == nil }),
+    .singularString({ $0.type }, fieldNumber: 3, isUnset: { $0._type == nil }),
+    .singularBool({ $0.reserved }, fieldNumber: 5, isUnset: { $0._reserved == nil }),
+    .singularBool({ $0.repeated }, fieldNumber: 6, isUnset: { $0._repeated == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_ExtensionRangeOptions.Declaration, rhs: Google_Protobuf_ExtensionRangeOptions.Declaration) -> Bool {
     if lhs._number != rhs._number {return false}
@@ -3520,46 +3418,20 @@ extension Google_Protobuf_FieldDescriptorProto: Message, _MessageImplementationB
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._name {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._extendee {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._number {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._label {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 4)
-    } }()
-    try { if let v = self._type {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 5)
-    } }()
-    try { if let v = self._typeName {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 6)
-    } }()
-    try { if let v = self._defaultValue {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 7)
-    } }()
-    try { if let v = self._options {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
-    } }()
-    try { if let v = self._oneofIndex {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 9)
-    } }()
-    try { if let v = self._jsonName {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 10)
-    } }()
-    try { if let v = self._proto3Optional {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 17)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
+    .singularString({ $0.extendee }, fieldNumber: 2, isUnset: { $0._extendee == nil }),
+    .singularInt32({ $0.number }, fieldNumber: 3, isUnset: { $0._number == nil }),
+    .singularEnum({ $0.label }, fieldNumber: 4, isUnset: { $0._label == nil }),
+    .singularEnum({ $0.type }, fieldNumber: 5, isUnset: { $0._type == nil }),
+    .singularString({ $0.typeName }, fieldNumber: 6, isUnset: { $0._typeName == nil }),
+    .singularString({ $0.defaultValue }, fieldNumber: 7, isUnset: { $0._defaultValue == nil }),
+    .singularMessage({ $0.options }, fieldNumber: 8, isUnset: { $0._options == nil }),
+    .singularInt32({ $0.oneofIndex }, fieldNumber: 9, isUnset: { $0._oneofIndex == nil }),
+    .singularString({ $0.jsonName }, fieldNumber: 10, isUnset: { $0._jsonName == nil }),
+    .singularBool({ $0.proto3Optional }, fieldNumber: 17, isUnset: { $0._proto3Optional == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FieldDescriptorProto, rhs: Google_Protobuf_FieldDescriptorProto) -> Bool {
     if lhs._name != rhs._name {return false}
@@ -3634,19 +3506,11 @@ extension Google_Protobuf_OneofDescriptorProto: Message, _MessageImplementationB
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._name {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._options {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
+    .singularMessage({ $0.options }, fieldNumber: 2, isUnset: { $0._options == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_OneofDescriptorProto, rhs: Google_Protobuf_OneofDescriptorProto) -> Bool {
     if lhs._name != rhs._name {return false}
@@ -3688,28 +3552,14 @@ extension Google_Protobuf_EnumDescriptorProto: Message, _MessageImplementationBa
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._name {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    if !self.value.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.value, fieldNumber: 2)
-    }
-    try { if let v = self._options {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    } }()
-    if !self.reservedRange.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.reservedRange, fieldNumber: 4)
-    }
-    if !self.reservedName.isEmpty {
-      try visitor.visitRepeatedStringField(value: self.reservedName, fieldNumber: 5)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
+    .repeatedMessage({ $0.value }, fieldNumber: 2),
+    .singularMessage({ $0.options }, fieldNumber: 3, isUnset: { $0._options == nil }),
+    .repeatedMessage({ $0.reservedRange }, fieldNumber: 4),
+    .repeatedString({ $0.reservedName }, fieldNumber: 5),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_EnumDescriptorProto, rhs: Google_Protobuf_EnumDescriptorProto) -> Bool {
     if lhs._name != rhs._name {return false}
@@ -3742,19 +3592,11 @@ extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: Message, _Messa
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._start {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._end {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.start }, fieldNumber: 1, isUnset: { $0._start == nil }),
+    .singularInt32({ $0.end }, fieldNumber: 2, isUnset: { $0._end == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_EnumDescriptorProto.EnumReservedRange, rhs: Google_Protobuf_EnumDescriptorProto.EnumReservedRange) -> Bool {
     if lhs._start != rhs._start {return false}
@@ -3791,22 +3633,12 @@ extension Google_Protobuf_EnumValueDescriptorProto: Message, _MessageImplementat
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._name {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._number {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._options {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
+    .singularInt32({ $0.number }, fieldNumber: 2, isUnset: { $0._number == nil }),
+    .singularMessage({ $0.options }, fieldNumber: 3, isUnset: { $0._options == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_EnumValueDescriptorProto, rhs: Google_Protobuf_EnumValueDescriptorProto) -> Bool {
     if lhs._name != rhs._name {return false}
@@ -3845,22 +3677,12 @@ extension Google_Protobuf_ServiceDescriptorProto: Message, _MessageImplementatio
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._name {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    if !self.method.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.method, fieldNumber: 2)
-    }
-    try { if let v = self._options {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
+    .repeatedMessage({ $0.method }, fieldNumber: 2),
+    .singularMessage({ $0.options }, fieldNumber: 3, isUnset: { $0._options == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_ServiceDescriptorProto, rhs: Google_Protobuf_ServiceDescriptorProto) -> Bool {
     if lhs._name != rhs._name {return false}
@@ -3904,31 +3726,15 @@ extension Google_Protobuf_MethodDescriptorProto: Message, _MessageImplementation
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._name {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._inputType {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._outputType {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._options {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
-    } }()
-    try { if let v = self._clientStreaming {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 5)
-    } }()
-    try { if let v = self._serverStreaming {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 6)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
+    .singularString({ $0.inputType }, fieldNumber: 2, isUnset: { $0._inputType == nil }),
+    .singularString({ $0.outputType }, fieldNumber: 3, isUnset: { $0._outputType == nil }),
+    .singularMessage({ $0.options }, fieldNumber: 4, isUnset: { $0._options == nil }),
+    .singularBool({ $0.clientStreaming }, fieldNumber: 5, isUnset: { $0._clientStreaming == nil }),
+    .singularBool({ $0.serverStreaming }, fieldNumber: 6, isUnset: { $0._serverStreaming == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_MethodDescriptorProto, rhs: Google_Protobuf_MethodDescriptorProto) -> Bool {
     if lhs._name != rhs._name {return false}
@@ -4077,82 +3883,32 @@ extension Google_Protobuf_FileOptions: Message, _MessageImplementationBase, _Pro
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._javaPackage {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._javaOuterClassname {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._optimizeFor {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._javaMultipleFiles {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._goPackage {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._ccGenericServices {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._javaGenericServices {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 17)
-      } }()
-      try { if let v = _storage._pyGenericServices {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._javaGenerateEqualsAndHash {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 20)
-      } }()
-      try { if let v = _storage._deprecated {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 23)
-      } }()
-      try { if let v = _storage._javaStringCheckUtf8 {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 27)
-      } }()
-      try { if let v = _storage._ccEnableArenas {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 31)
-      } }()
-      try { if let v = _storage._objcClassPrefix {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 36)
-      } }()
-      try { if let v = _storage._csharpNamespace {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 37)
-      } }()
-      try { if let v = _storage._swiftPrefix {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 39)
-      } }()
-      try { if let v = _storage._phpClassPrefix {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 40)
-      } }()
-      try { if let v = _storage._phpNamespace {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 41)
-      } }()
-      try { if let v = _storage._phpGenericServices {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 42)
-      } }()
-      try { if let v = _storage._phpMetadataNamespace {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 44)
-      } }()
-      try { if let v = _storage._rubyPackage {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 45)
-      } }()
-      try { if let v = _storage._features {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 50)
-      } }()
-      if !_storage._uninterpretedOption.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._uninterpretedOption, fieldNumber: 999)
-      }
-      try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.javaPackage }, fieldNumber: 1, isUnset: { $0._storage._javaPackage == nil }),
+    .singularString({ $0.javaOuterClassname }, fieldNumber: 8, isUnset: { $0._storage._javaOuterClassname == nil }),
+    .singularEnum({ $0.optimizeFor }, fieldNumber: 9, isUnset: { $0._storage._optimizeFor == nil }),
+    .singularBool({ $0.javaMultipleFiles }, fieldNumber: 10, isUnset: { $0._storage._javaMultipleFiles == nil }),
+    .singularString({ $0.goPackage }, fieldNumber: 11, isUnset: { $0._storage._goPackage == nil }),
+    .singularBool({ $0.ccGenericServices }, fieldNumber: 16, isUnset: { $0._storage._ccGenericServices == nil }),
+    .singularBool({ $0.javaGenericServices }, fieldNumber: 17, isUnset: { $0._storage._javaGenericServices == nil }),
+    .singularBool({ $0.pyGenericServices }, fieldNumber: 18, isUnset: { $0._storage._pyGenericServices == nil }),
+    .singularBool({ $0.javaGenerateEqualsAndHash }, fieldNumber: 20, isUnset: { $0._storage._javaGenerateEqualsAndHash == nil }),
+    .singularBool({ $0.deprecated }, fieldNumber: 23, isUnset: { $0._storage._deprecated == nil }),
+    .singularBool({ $0.javaStringCheckUtf8 }, fieldNumber: 27, isUnset: { $0._storage._javaStringCheckUtf8 == nil }),
+    .singularBool({ $0.ccEnableArenas }, fieldNumber: 31, isUnset: { $0._storage._ccEnableArenas == nil }),
+    .singularString({ $0.objcClassPrefix }, fieldNumber: 36, isUnset: { $0._storage._objcClassPrefix == nil }),
+    .singularString({ $0.csharpNamespace }, fieldNumber: 37, isUnset: { $0._storage._csharpNamespace == nil }),
+    .singularString({ $0.swiftPrefix }, fieldNumber: 39, isUnset: { $0._storage._swiftPrefix == nil }),
+    .singularString({ $0.phpClassPrefix }, fieldNumber: 40, isUnset: { $0._storage._phpClassPrefix == nil }),
+    .singularString({ $0.phpNamespace }, fieldNumber: 41, isUnset: { $0._storage._phpNamespace == nil }),
+    .singularBool({ $0.phpGenericServices }, fieldNumber: 42, isUnset: { $0._storage._phpGenericServices == nil }),
+    .singularString({ $0.phpMetadataNamespace }, fieldNumber: 44, isUnset: { $0._storage._phpMetadataNamespace == nil }),
+    .singularString({ $0.rubyPackage }, fieldNumber: 45, isUnset: { $0._storage._rubyPackage == nil }),
+    .singularMessage({ $0.features }, fieldNumber: 50, isUnset: { $0._storage._features == nil }),
+    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FileOptions, rhs: Google_Protobuf_FileOptions) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -4238,35 +3994,17 @@ extension Google_Protobuf_MessageOptions: Message, _MessageImplementationBase, _
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._messageSetWireFormat {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._noStandardDescriptorAccessor {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._deprecated {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._mapEntry {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 7)
-    } }()
-    try { if let v = self._deprecatedLegacyJsonFieldConflicts {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 11)
-    } }()
-    try { if let v = self._features {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 12)
-    } }()
-    if !self.uninterpretedOption.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999)
-    }
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularBool({ $0.messageSetWireFormat }, fieldNumber: 1, isUnset: { $0._messageSetWireFormat == nil }),
+    .singularBool({ $0.noStandardDescriptorAccessor }, fieldNumber: 2, isUnset: { $0._noStandardDescriptorAccessor == nil }),
+    .singularBool({ $0.deprecated }, fieldNumber: 3, isUnset: { $0._deprecated == nil }),
+    .singularBool({ $0.mapEntry }, fieldNumber: 7, isUnset: { $0._mapEntry == nil }),
+    .singularBool({ $0.deprecatedLegacyJsonFieldConflicts }, fieldNumber: 11, isUnset: { $0._deprecatedLegacyJsonFieldConflicts == nil }),
+    .singularMessage({ $0.features }, fieldNumber: 12, isUnset: { $0._features == nil }),
+    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_MessageOptions, rhs: Google_Protobuf_MessageOptions) -> Bool {
     if lhs._messageSetWireFormat != rhs._messageSetWireFormat {return false}
@@ -4381,55 +4119,23 @@ extension Google_Protobuf_FieldOptions: Message, _MessageImplementationBase, _Pr
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._ctype {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._packed {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._deprecated {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._lazy {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._jstype {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._weak {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._unverifiedLazy {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._debugRedact {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._retention {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 17)
-      } }()
-      if !_storage._targets.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._targets, fieldNumber: 19)
-      }
-      if !_storage._editionDefaults.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._editionDefaults, fieldNumber: 20)
-      }
-      try { if let v = _storage._features {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 21)
-      } }()
-      if !_storage._uninterpretedOption.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._uninterpretedOption, fieldNumber: 999)
-      }
-      try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularEnum({ $0.ctype }, fieldNumber: 1, isUnset: { $0._storage._ctype == nil }),
+    .singularBool({ $0.packed }, fieldNumber: 2, isUnset: { $0._storage._packed == nil }),
+    .singularBool({ $0.deprecated }, fieldNumber: 3, isUnset: { $0._storage._deprecated == nil }),
+    .singularBool({ $0.lazy }, fieldNumber: 5, isUnset: { $0._storage._lazy == nil }),
+    .singularEnum({ $0.jstype }, fieldNumber: 6, isUnset: { $0._storage._jstype == nil }),
+    .singularBool({ $0.weak }, fieldNumber: 10, isUnset: { $0._storage._weak == nil }),
+    .singularBool({ $0.unverifiedLazy }, fieldNumber: 15, isUnset: { $0._storage._unverifiedLazy == nil }),
+    .singularBool({ $0.debugRedact }, fieldNumber: 16, isUnset: { $0._storage._debugRedact == nil }),
+    .singularEnum({ $0.retention }, fieldNumber: 17, isUnset: { $0._storage._retention == nil }),
+    .repeatedEnum({ $0.targets }, fieldNumber: 19),
+    .repeatedMessage({ $0.editionDefaults }, fieldNumber: 20),
+    .singularMessage({ $0.features }, fieldNumber: 21, isUnset: { $0._storage._features == nil }),
+    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FieldOptions, rhs: Google_Protobuf_FieldOptions) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -4518,19 +4224,11 @@ extension Google_Protobuf_FieldOptions.EditionDefault: Message, _MessageImplemen
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._value {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._edition {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.value }, fieldNumber: 2, isUnset: { $0._value == nil }),
+    .singularEnum({ $0.edition }, fieldNumber: 3, isUnset: { $0._edition == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FieldOptions.EditionDefault, rhs: Google_Protobuf_FieldOptions.EditionDefault) -> Bool {
     if lhs._edition != rhs._edition {return false}
@@ -4569,20 +4267,12 @@ extension Google_Protobuf_OneofOptions: Message, _MessageImplementationBase, _Pr
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._features {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    } }()
-    if !self.uninterpretedOption.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999)
-    }
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.features }, fieldNumber: 1, isUnset: { $0._features == nil }),
+    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_OneofOptions, rhs: Google_Protobuf_OneofOptions) -> Bool {
     if lhs._features != rhs._features {return false}
@@ -4628,29 +4318,15 @@ extension Google_Protobuf_EnumOptions: Message, _MessageImplementationBase, _Pro
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._allowAlias {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._deprecated {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._deprecatedLegacyJsonFieldConflicts {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 6)
-    } }()
-    try { if let v = self._features {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
-    } }()
-    if !self.uninterpretedOption.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999)
-    }
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularBool({ $0.allowAlias }, fieldNumber: 2, isUnset: { $0._allowAlias == nil }),
+    .singularBool({ $0.deprecated }, fieldNumber: 3, isUnset: { $0._deprecated == nil }),
+    .singularBool({ $0.deprecatedLegacyJsonFieldConflicts }, fieldNumber: 6, isUnset: { $0._deprecatedLegacyJsonFieldConflicts == nil }),
+    .singularMessage({ $0.features }, fieldNumber: 7, isUnset: { $0._features == nil }),
+    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_EnumOptions, rhs: Google_Protobuf_EnumOptions) -> Bool {
     if lhs._allowAlias != rhs._allowAlias {return false}
@@ -4697,26 +4373,14 @@ extension Google_Protobuf_EnumValueOptions: Message, _MessageImplementationBase,
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._deprecated {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._features {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._debugRedact {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 3)
-    } }()
-    if !self.uninterpretedOption.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999)
-    }
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularBool({ $0.deprecated }, fieldNumber: 1, isUnset: { $0._deprecated == nil }),
+    .singularMessage({ $0.features }, fieldNumber: 2, isUnset: { $0._features == nil }),
+    .singularBool({ $0.debugRedact }, fieldNumber: 3, isUnset: { $0._debugRedact == nil }),
+    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_EnumValueOptions, rhs: Google_Protobuf_EnumValueOptions) -> Bool {
     if lhs._deprecated != rhs._deprecated {return false}
@@ -4760,23 +4424,13 @@ extension Google_Protobuf_ServiceOptions: Message, _MessageImplementationBase, _
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._deprecated {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 33)
-    } }()
-    try { if let v = self._features {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 34)
-    } }()
-    if !self.uninterpretedOption.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999)
-    }
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularBool({ $0.deprecated }, fieldNumber: 33, isUnset: { $0._deprecated == nil }),
+    .singularMessage({ $0.features }, fieldNumber: 34, isUnset: { $0._features == nil }),
+    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_ServiceOptions, rhs: Google_Protobuf_ServiceOptions) -> Bool {
     if lhs._features != rhs._features {return false}
@@ -4821,26 +4475,14 @@ extension Google_Protobuf_MethodOptions: Message, _MessageImplementationBase, _P
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._deprecated {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 33)
-    } }()
-    try { if let v = self._idempotencyLevel {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 34)
-    } }()
-    try { if let v = self._features {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 35)
-    } }()
-    if !self.uninterpretedOption.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999)
-    }
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularBool({ $0.deprecated }, fieldNumber: 33, isUnset: { $0._deprecated == nil }),
+    .singularEnum({ $0.idempotencyLevel }, fieldNumber: 34, isUnset: { $0._idempotencyLevel == nil }),
+    .singularMessage({ $0.features }, fieldNumber: 35, isUnset: { $0._features == nil }),
+    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_MethodOptions, rhs: Google_Protobuf_MethodOptions) -> Bool {
     if lhs._deprecated != rhs._deprecated {return false}
@@ -4896,34 +4538,16 @@ extension Google_Protobuf_UninterpretedOption: Message, _MessageImplementationBa
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if !self.name.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.name, fieldNumber: 2)
-    }
-    try { if let v = self._identifierValue {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._positiveIntValue {
-      try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4)
-    } }()
-    try { if let v = self._negativeIntValue {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 5)
-    } }()
-    try { if let v = self._doubleValue {
-      try visitor.visitSingularDoubleField(value: v, fieldNumber: 6)
-    } }()
-    try { if let v = self._stringValue {
-      try visitor.visitSingularBytesField(value: v, fieldNumber: 7)
-    } }()
-    try { if let v = self._aggregateValue {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 8)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.name }, fieldNumber: 2),
+    .singularString({ $0.identifierValue }, fieldNumber: 3, isUnset: { $0._identifierValue == nil }),
+    .singularUInt64({ $0.positiveIntValue }, fieldNumber: 4, isUnset: { $0._positiveIntValue == nil }),
+    .singularInt64({ $0.negativeIntValue }, fieldNumber: 5, isUnset: { $0._negativeIntValue == nil }),
+    .singularDouble({ $0.doubleValue }, fieldNumber: 6, isUnset: { $0._doubleValue == nil }),
+    .singularBytes({ $0.stringValue }, fieldNumber: 7, isUnset: { $0._stringValue == nil }),
+    .singularString({ $0.aggregateValue }, fieldNumber: 8, isUnset: { $0._aggregateValue == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_UninterpretedOption, rhs: Google_Protobuf_UninterpretedOption) -> Bool {
     if lhs.name != rhs.name {return false}
@@ -4964,19 +4588,11 @@ extension Google_Protobuf_UninterpretedOption.NamePart: Message, _MessageImpleme
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._namePart {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._isExtension {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 2)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.namePart }, fieldNumber: 1, isUnset: { $0._namePart == nil }),
+    .singularBool({ $0.isExtension }, fieldNumber: 2, isUnset: { $0._isExtension == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_UninterpretedOption.NamePart, rhs: Google_Protobuf_UninterpretedOption.NamePart) -> Bool {
     if lhs._namePart != rhs._namePart {return false}
@@ -5021,32 +4637,16 @@ extension Google_Protobuf_FeatureSet: Message, _MessageImplementationBase, _Prot
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._fieldPresence {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._enumType {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._repeatedFieldEncoding {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._utf8Validation {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 4)
-    } }()
-    try { if let v = self._messageEncoding {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 5)
-    } }()
-    try { if let v = self._jsonFormat {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 6)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 10000)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularEnum({ $0.fieldPresence }, fieldNumber: 1, isUnset: { $0._fieldPresence == nil }),
+    .singularEnum({ $0.enumType }, fieldNumber: 2, isUnset: { $0._enumType == nil }),
+    .singularEnum({ $0.repeatedFieldEncoding }, fieldNumber: 3, isUnset: { $0._repeatedFieldEncoding == nil }),
+    .singularEnum({ $0.utf8Validation }, fieldNumber: 4, isUnset: { $0._utf8Validation == nil }),
+    .singularEnum({ $0.messageEncoding }, fieldNumber: 5, isUnset: { $0._messageEncoding == nil }),
+    .singularEnum({ $0.jsonFormat }, fieldNumber: 6, isUnset: { $0._jsonFormat == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 10000),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FeatureSet, rhs: Google_Protobuf_FeatureSet) -> Bool {
     if lhs._fieldPresence != rhs._fieldPresence {return false}
@@ -5137,22 +4737,12 @@ extension Google_Protobuf_FeatureSetDefaults: Message, _MessageImplementationBas
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if !self.defaults.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.defaults, fieldNumber: 1)
-    }
-    try { if let v = self._minimumEdition {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 4)
-    } }()
-    try { if let v = self._maximumEdition {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 5)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.defaults }, fieldNumber: 1),
+    .singularEnum({ $0.minimumEdition }, fieldNumber: 4, isUnset: { $0._minimumEdition == nil }),
+    .singularEnum({ $0.maximumEdition }, fieldNumber: 5, isUnset: { $0._maximumEdition == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FeatureSetDefaults, rhs: Google_Protobuf_FeatureSetDefaults) -> Bool {
     if lhs.defaults != rhs.defaults {return false}
@@ -5188,19 +4778,11 @@ extension Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault: Message,
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._features {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._edition {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.features }, fieldNumber: 2, isUnset: { $0._features == nil }),
+    .singularEnum({ $0.edition }, fieldNumber: 3, isUnset: { $0._edition == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault, rhs: Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault) -> Bool {
     if lhs._edition != rhs._edition {return false}
@@ -5228,12 +4810,10 @@ extension Google_Protobuf_SourceCodeInfo: Message, _MessageImplementationBase, _
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.location.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.location, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.location }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_SourceCodeInfo, rhs: Google_Protobuf_SourceCodeInfo) -> Bool {
     if lhs.location != rhs.location {return false}
@@ -5268,28 +4848,14 @@ extension Google_Protobuf_SourceCodeInfo.Location: Message, _MessageImplementati
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if !self.path.isEmpty {
-      try visitor.visitPackedInt32Field(value: self.path, fieldNumber: 1)
-    }
-    if !self.span.isEmpty {
-      try visitor.visitPackedInt32Field(value: self.span, fieldNumber: 2)
-    }
-    try { if let v = self._leadingComments {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._trailingComments {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 4)
-    } }()
-    if !self.leadingDetachedComments.isEmpty {
-      try visitor.visitRepeatedStringField(value: self.leadingDetachedComments, fieldNumber: 6)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .packedInt32({ $0.path }, fieldNumber: 1),
+    .packedInt32({ $0.span }, fieldNumber: 2),
+    .singularString({ $0.leadingComments }, fieldNumber: 3, isUnset: { $0._leadingComments == nil }),
+    .singularString({ $0.trailingComments }, fieldNumber: 4, isUnset: { $0._trailingComments == nil }),
+    .repeatedString({ $0.leadingDetachedComments }, fieldNumber: 6),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_SourceCodeInfo.Location, rhs: Google_Protobuf_SourceCodeInfo.Location) -> Bool {
     if lhs.path != rhs.path {return false}
@@ -5320,12 +4886,10 @@ extension Google_Protobuf_GeneratedCodeInfo: Message, _MessageImplementationBase
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.annotation.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.annotation, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.annotation }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_GeneratedCodeInfo, rhs: Google_Protobuf_GeneratedCodeInfo) -> Bool {
     if lhs.annotation != rhs.annotation {return false}
@@ -5360,28 +4924,14 @@ extension Google_Protobuf_GeneratedCodeInfo.Annotation: Message, _MessageImpleme
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if !self.path.isEmpty {
-      try visitor.visitPackedInt32Field(value: self.path, fieldNumber: 1)
-    }
-    try { if let v = self._sourceFile {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._begin {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._end {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 4)
-    } }()
-    try { if let v = self._semantic {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 5)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .packedInt32({ $0.path }, fieldNumber: 1),
+    .singularString({ $0.sourceFile }, fieldNumber: 2, isUnset: { $0._sourceFile == nil }),
+    .singularInt32({ $0.begin }, fieldNumber: 3, isUnset: { $0._begin == nil }),
+    .singularInt32({ $0.end }, fieldNumber: 4, isUnset: { $0._end == nil }),
+    .singularEnum({ $0.semantic }, fieldNumber: 5, isUnset: { $0._semantic == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_GeneratedCodeInfo.Annotation, rhs: Google_Protobuf_GeneratedCodeInfo.Annotation) -> Bool {
     if lhs.path != rhs.path {return false}
diff --git a/Sources/SwiftProtobuf/duration.pb.swift b/Sources/SwiftProtobuf/duration.pb.swift
index 565ef3f6d..6624d75d7 100644
--- a/Sources/SwiftProtobuf/duration.pb.swift
+++ b/Sources/SwiftProtobuf/duration.pb.swift
@@ -154,15 +154,11 @@ extension Google_Protobuf_Duration: Message, _MessageImplementationBase, _ProtoN
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if self.seconds != 0 {
-      try visitor.visitSingularInt64Field(value: self.seconds, fieldNumber: 1)
-    }
-    if self.nanos != 0 {
-      try visitor.visitSingularInt32Field(value: self.nanos, fieldNumber: 2)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.seconds }, fieldNumber: 1),
+    .singularInt32({ $0.nanos }, fieldNumber: 2),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Duration, rhs: Google_Protobuf_Duration) -> Bool {
     if lhs.seconds != rhs.seconds {return false}
diff --git a/Sources/SwiftProtobuf/empty.pb.swift b/Sources/SwiftProtobuf/empty.pb.swift
index 436e38e4b..df485382c 100644
--- a/Sources/SwiftProtobuf/empty.pb.swift
+++ b/Sources/SwiftProtobuf/empty.pb.swift
@@ -79,9 +79,9 @@ extension Google_Protobuf_Empty: Message, _MessageImplementationBase, _ProtoName
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Empty, rhs: Google_Protobuf_Empty) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
diff --git a/Sources/SwiftProtobuf/field_mask.pb.swift b/Sources/SwiftProtobuf/field_mask.pb.swift
index 8d6be191b..48ee85108 100644
--- a/Sources/SwiftProtobuf/field_mask.pb.swift
+++ b/Sources/SwiftProtobuf/field_mask.pb.swift
@@ -283,12 +283,10 @@ extension Google_Protobuf_FieldMask: Message, _MessageImplementationBase, _Proto
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.paths.isEmpty {
-      try visitor.visitRepeatedStringField(value: self.paths, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .repeatedString({ $0.paths }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FieldMask, rhs: Google_Protobuf_FieldMask) -> Bool {
     if lhs.paths != rhs.paths {return false}
diff --git a/Sources/SwiftProtobuf/source_context.pb.swift b/Sources/SwiftProtobuf/source_context.pb.swift
index 25a034385..4d812c1a8 100644
--- a/Sources/SwiftProtobuf/source_context.pb.swift
+++ b/Sources/SwiftProtobuf/source_context.pb.swift
@@ -87,12 +87,10 @@ extension Google_Protobuf_SourceContext: Message, _MessageImplementationBase, _P
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.fileName.isEmpty {
-      try visitor.visitSingularStringField(value: self.fileName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.fileName }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_SourceContext, rhs: Google_Protobuf_SourceContext) -> Bool {
     if lhs.fileName != rhs.fileName {return false}
diff --git a/Sources/SwiftProtobuf/struct.pb.swift b/Sources/SwiftProtobuf/struct.pb.swift
index ca15b48b3..6717e9590 100644
--- a/Sources/SwiftProtobuf/struct.pb.swift
+++ b/Sources/SwiftProtobuf/struct.pb.swift
@@ -240,12 +240,10 @@ extension Google_Protobuf_Struct: Message, _MessageImplementationBase, _ProtoNam
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.fields.isEmpty {
-      try visitor.visitMapField(fieldType: _ProtobufMessageMap<ProtobufString,Google_Protobuf_Value>.self, value: self.fields, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .map(type: _ProtobufMessageMap<ProtobufString,Google_Protobuf_Value>.self, { $0.fields }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Struct, rhs: Google_Protobuf_Struct) -> Bool {
     if lhs.fields != rhs.fields {return false}
@@ -334,40 +332,31 @@ extension Google_Protobuf_Value: Message, _MessageImplementationBase, _ProtoName
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    switch self.kind {
-    case .nullValue?: try {
-      guard case .nullValue(let v)? = self.kind else { preconditionFailure() }
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
-    }()
-    case .numberValue?: try {
-      guard case .numberValue(let v)? = self.kind else { preconditionFailure() }
-      try visitor.visitSingularDoubleField(value: v, fieldNumber: 2)
-    }()
-    case .stringValue?: try {
-      guard case .stringValue(let v)? = self.kind else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
-    }()
-    case .boolValue?: try {
-      guard case .boolValue(let v)? = self.kind else { preconditionFailure() }
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 4)
-    }()
-    case .structValue?: try {
-      guard case .structValue(let v)? = self.kind else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
-    }()
-    case .listValue?: try {
-      guard case .listValue(let v)? = self.kind else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 6)
-    }()
-    case nil: break
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .oneOf({ $0.kind }) {
+      switch $0 {
+      case .nullValue:
+        return _oneOfField_nullValue
+      case .numberValue:
+        return _oneOfField_numberValue
+      case .stringValue:
+        return _oneOfField_stringValue
+      case .boolValue:
+        return _oneOfField_boolValue
+      case .structValue:
+        return _oneOfField_structValue
+      case .listValue:
+        return _oneOfField_listValue
+      }
+    },
+  ]
+  private static let _oneOfField_nullValue: Field<Self> = .singularEnum({ $0.nullValue }, fieldNumber: 1, isUnset: { _ in false })
+  private static let _oneOfField_numberValue: Field<Self> = .singularDouble({ $0.numberValue }, fieldNumber: 2, isUnset: { _ in false })
+  private static let _oneOfField_stringValue: Field<Self> = .singularString({ $0.stringValue }, fieldNumber: 3, isUnset: { _ in false })
+  private static let _oneOfField_boolValue: Field<Self> = .singularBool({ $0.boolValue }, fieldNumber: 4, isUnset: { _ in false })
+  private static let _oneOfField_structValue: Field<Self> = .singularMessage({ $0.structValue }, fieldNumber: 5, isUnset: { _ in false })
+  private static let _oneOfField_listValue: Field<Self> = .singularMessage({ $0.listValue }, fieldNumber: 6, isUnset: { _ in false })
+
 
   public static func ==(lhs: Google_Protobuf_Value, rhs: Google_Protobuf_Value) -> Bool {
     if lhs.kind != rhs.kind {return false}
@@ -394,12 +383,10 @@ extension Google_Protobuf_ListValue: Message, _MessageImplementationBase, _Proto
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.values.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.values, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.values }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_ListValue, rhs: Google_Protobuf_ListValue) -> Bool {
     if lhs.values != rhs.values {return false}
diff --git a/Sources/SwiftProtobuf/timestamp.pb.swift b/Sources/SwiftProtobuf/timestamp.pb.swift
index 2d43c2e32..52645e739 100644
--- a/Sources/SwiftProtobuf/timestamp.pb.swift
+++ b/Sources/SwiftProtobuf/timestamp.pb.swift
@@ -183,15 +183,11 @@ extension Google_Protobuf_Timestamp: Message, _MessageImplementationBase, _Proto
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if self.seconds != 0 {
-      try visitor.visitSingularInt64Field(value: self.seconds, fieldNumber: 1)
-    }
-    if self.nanos != 0 {
-      try visitor.visitSingularInt32Field(value: self.nanos, fieldNumber: 2)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.seconds }, fieldNumber: 1),
+    .singularInt32({ $0.nanos }, fieldNumber: 2),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Timestamp, rhs: Google_Protobuf_Timestamp) -> Bool {
     if lhs.seconds != rhs.seconds {return false}
diff --git a/Sources/SwiftProtobuf/type.pb.swift b/Sources/SwiftProtobuf/type.pb.swift
index 04433403e..060185c67 100644
--- a/Sources/SwiftProtobuf/type.pb.swift
+++ b/Sources/SwiftProtobuf/type.pb.swift
@@ -503,34 +503,16 @@ extension Google_Protobuf_Type: Message, _MessageImplementationBase, _ProtoNameP
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if !self.name.isEmpty {
-      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
-    }
-    if !self.fields.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.fields, fieldNumber: 2)
-    }
-    if !self.oneofs.isEmpty {
-      try visitor.visitRepeatedStringField(value: self.oneofs, fieldNumber: 3)
-    }
-    if !self.options.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 4)
-    }
-    try { if let v = self._sourceContext {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
-    } }()
-    if self.syntax != .proto2 {
-      try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 6)
-    }
-    if !self.edition.isEmpty {
-      try visitor.visitSingularStringField(value: self.edition, fieldNumber: 7)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1),
+    .repeatedMessage({ $0.fields }, fieldNumber: 2),
+    .repeatedString({ $0.oneofs }, fieldNumber: 3),
+    .repeatedMessage({ $0.options }, fieldNumber: 4),
+    .singularMessage({ $0.sourceContext }, fieldNumber: 5, isUnset: { $0._sourceContext == nil }),
+    .singularEnum({ $0.syntax }, fieldNumber: 6, defaultValue: .proto2),
+    .singularString({ $0.edition }, fieldNumber: 7),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Type, rhs: Google_Protobuf_Type) -> Bool {
     if lhs.name != rhs.name {return false}
@@ -581,39 +563,19 @@ extension Google_Protobuf_Field: Message, _MessageImplementationBase, _ProtoName
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if self.kind != .typeUnknown {
-      try visitor.visitSingularEnumField(value: self.kind, fieldNumber: 1)
-    }
-    if self.cardinality != .unknown {
-      try visitor.visitSingularEnumField(value: self.cardinality, fieldNumber: 2)
-    }
-    if self.number != 0 {
-      try visitor.visitSingularInt32Field(value: self.number, fieldNumber: 3)
-    }
-    if !self.name.isEmpty {
-      try visitor.visitSingularStringField(value: self.name, fieldNumber: 4)
-    }
-    if !self.typeURL.isEmpty {
-      try visitor.visitSingularStringField(value: self.typeURL, fieldNumber: 6)
-    }
-    if self.oneofIndex != 0 {
-      try visitor.visitSingularInt32Field(value: self.oneofIndex, fieldNumber: 7)
-    }
-    if self.packed != false {
-      try visitor.visitSingularBoolField(value: self.packed, fieldNumber: 8)
-    }
-    if !self.options.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 9)
-    }
-    if !self.jsonName.isEmpty {
-      try visitor.visitSingularStringField(value: self.jsonName, fieldNumber: 10)
-    }
-    if !self.defaultValue.isEmpty {
-      try visitor.visitSingularStringField(value: self.defaultValue, fieldNumber: 11)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularEnum({ $0.kind }, fieldNumber: 1, defaultValue: .typeUnknown),
+    .singularEnum({ $0.cardinality }, fieldNumber: 2, defaultValue: .unknown),
+    .singularInt32({ $0.number }, fieldNumber: 3),
+    .singularString({ $0.name }, fieldNumber: 4),
+    .singularString({ $0.typeURL }, fieldNumber: 6),
+    .singularInt32({ $0.oneofIndex }, fieldNumber: 7),
+    .singularBool({ $0.packed }, fieldNumber: 8),
+    .repeatedMessage({ $0.options }, fieldNumber: 9),
+    .singularString({ $0.jsonName }, fieldNumber: 10),
+    .singularString({ $0.defaultValue }, fieldNumber: 11),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Field, rhs: Google_Protobuf_Field) -> Bool {
     if lhs.kind != rhs.kind {return false}
@@ -692,31 +654,15 @@ extension Google_Protobuf_Enum: Message, _MessageImplementationBase, _ProtoNameP
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if !self.name.isEmpty {
-      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
-    }
-    if !self.enumvalue.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.enumvalue, fieldNumber: 2)
-    }
-    if !self.options.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 3)
-    }
-    try { if let v = self._sourceContext {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
-    } }()
-    if self.syntax != .proto2 {
-      try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 5)
-    }
-    if !self.edition.isEmpty {
-      try visitor.visitSingularStringField(value: self.edition, fieldNumber: 6)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1),
+    .repeatedMessage({ $0.enumvalue }, fieldNumber: 2),
+    .repeatedMessage({ $0.options }, fieldNumber: 3),
+    .singularMessage({ $0.sourceContext }, fieldNumber: 4, isUnset: { $0._sourceContext == nil }),
+    .singularEnum({ $0.syntax }, fieldNumber: 5, defaultValue: .proto2),
+    .singularString({ $0.edition }, fieldNumber: 6),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Enum, rhs: Google_Protobuf_Enum) -> Bool {
     if lhs.name != rhs.name {return false}
@@ -752,18 +698,12 @@ extension Google_Protobuf_EnumValue: Message, _MessageImplementationBase, _Proto
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.name.isEmpty {
-      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
-    }
-    if self.number != 0 {
-      try visitor.visitSingularInt32Field(value: self.number, fieldNumber: 2)
-    }
-    if !self.options.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 3)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1),
+    .singularInt32({ $0.number }, fieldNumber: 2),
+    .repeatedMessage({ $0.options }, fieldNumber: 3),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_EnumValue, rhs: Google_Protobuf_EnumValue) -> Bool {
     if lhs.name != rhs.name {return false}
@@ -794,19 +734,11 @@ extension Google_Protobuf_Option: Message, _MessageImplementationBase, _ProtoNam
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if !self.name.isEmpty {
-      try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
-    }
-    try { if let v = self._value {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1),
+    .singularMessage({ $0.value }, fieldNumber: 2, isUnset: { $0._value == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Option, rhs: Google_Protobuf_Option) -> Bool {
     if lhs.name != rhs.name {return false}
diff --git a/Sources/SwiftProtobuf/wrappers.pb.swift b/Sources/SwiftProtobuf/wrappers.pb.swift
index 2c3c87b31..9ed0cabbf 100644
--- a/Sources/SwiftProtobuf/wrappers.pb.swift
+++ b/Sources/SwiftProtobuf/wrappers.pb.swift
@@ -225,12 +225,10 @@ extension Google_Protobuf_DoubleValue: Message, _MessageImplementationBase, _Pro
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if self.value != 0 {
-      try visitor.visitSingularDoubleField(value: self.value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularDouble({ $0.value }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_DoubleValue, rhs: Google_Protobuf_DoubleValue) -> Bool {
     if lhs.value != rhs.value {return false}
@@ -257,12 +255,10 @@ extension Google_Protobuf_FloatValue: Message, _MessageImplementationBase, _Prot
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if self.value != 0 {
-      try visitor.visitSingularFloatField(value: self.value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularFloat({ $0.value }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_FloatValue, rhs: Google_Protobuf_FloatValue) -> Bool {
     if lhs.value != rhs.value {return false}
@@ -289,12 +285,10 @@ extension Google_Protobuf_Int64Value: Message, _MessageImplementationBase, _Prot
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if self.value != 0 {
-      try visitor.visitSingularInt64Field(value: self.value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.value }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Int64Value, rhs: Google_Protobuf_Int64Value) -> Bool {
     if lhs.value != rhs.value {return false}
@@ -321,12 +315,10 @@ extension Google_Protobuf_UInt64Value: Message, _MessageImplementationBase, _Pro
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if self.value != 0 {
-      try visitor.visitSingularUInt64Field(value: self.value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularUInt64({ $0.value }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_UInt64Value, rhs: Google_Protobuf_UInt64Value) -> Bool {
     if lhs.value != rhs.value {return false}
@@ -353,12 +345,10 @@ extension Google_Protobuf_Int32Value: Message, _MessageImplementationBase, _Prot
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if self.value != 0 {
-      try visitor.visitSingularInt32Field(value: self.value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.value }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Int32Value, rhs: Google_Protobuf_Int32Value) -> Bool {
     if lhs.value != rhs.value {return false}
@@ -385,12 +375,10 @@ extension Google_Protobuf_UInt32Value: Message, _MessageImplementationBase, _Pro
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if self.value != 0 {
-      try visitor.visitSingularUInt32Field(value: self.value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularUInt32({ $0.value }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_UInt32Value, rhs: Google_Protobuf_UInt32Value) -> Bool {
     if lhs.value != rhs.value {return false}
@@ -417,12 +405,10 @@ extension Google_Protobuf_BoolValue: Message, _MessageImplementationBase, _Proto
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if self.value != false {
-      try visitor.visitSingularBoolField(value: self.value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularBool({ $0.value }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_BoolValue, rhs: Google_Protobuf_BoolValue) -> Bool {
     if lhs.value != rhs.value {return false}
@@ -449,12 +435,10 @@ extension Google_Protobuf_StringValue: Message, _MessageImplementationBase, _Pro
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.value.isEmpty {
-      try visitor.visitSingularStringField(value: self.value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.value }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_StringValue, rhs: Google_Protobuf_StringValue) -> Bool {
     if lhs.value != rhs.value {return false}
@@ -481,12 +465,10 @@ extension Google_Protobuf_BytesValue: Message, _MessageImplementationBase, _Prot
     }
   }
 
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    if !self.value.isEmpty {
-      try visitor.visitSingularBytesField(value: self.value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularBytes({ $0.value }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_BytesValue, rhs: Google_Protobuf_BytesValue) -> Bool {
     if lhs.value != rhs.value {return false}
diff --git a/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift b/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift
index de9ce1722..9eeff24d3 100644
--- a/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift
+++ b/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift
@@ -393,25 +393,13 @@ extension Google_Protobuf_Compiler_Version: SwiftProtobuf.Message, SwiftProtobuf
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._major {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._minor {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._patch {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._suffix {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 4)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.major }, fieldNumber: 1, isUnset: { $0._major == nil }),
+    .singularInt32({ $0.minor }, fieldNumber: 2, isUnset: { $0._minor == nil }),
+    .singularInt32({ $0.patch }, fieldNumber: 3, isUnset: { $0._patch == nil }),
+    .singularString({ $0.suffix }, fieldNumber: 4, isUnset: { $0._suffix == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Compiler_Version, rhs: Google_Protobuf_Compiler_Version) -> Bool {
     if lhs._major != rhs._major {return false}
@@ -455,28 +443,14 @@ extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message,
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if !self.fileToGenerate.isEmpty {
-      try visitor.visitRepeatedStringField(value: self.fileToGenerate, fieldNumber: 1)
-    }
-    try { if let v = self._parameter {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._compilerVersion {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    } }()
-    if !self.protoFile.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.protoFile, fieldNumber: 15)
-    }
-    if !self.sourceFileDescriptors.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.sourceFileDescriptors, fieldNumber: 17)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .repeatedString({ $0.fileToGenerate }, fieldNumber: 1),
+    .singularString({ $0.parameter }, fieldNumber: 2, isUnset: { $0._parameter == nil }),
+    .singularMessage({ $0.compilerVersion }, fieldNumber: 3, isUnset: { $0._compilerVersion == nil }),
+    .repeatedMessage({ $0.protoFile }, fieldNumber: 15),
+    .repeatedMessage({ $0.sourceFileDescriptors }, fieldNumber: 17),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Compiler_CodeGeneratorRequest, rhs: Google_Protobuf_Compiler_CodeGeneratorRequest) -> Bool {
     if lhs.fileToGenerate != rhs.fileToGenerate {return false}
@@ -515,28 +489,14 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message,
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._error {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._supportedFeatures {
-      try visitor.visitSingularUInt64Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._minimumEdition {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._maximumEdition {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 4)
-    } }()
-    if !self.file.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.file, fieldNumber: 15)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.error }, fieldNumber: 1, isUnset: { $0._error == nil }),
+    .singularUInt64({ $0.supportedFeatures }, fieldNumber: 2, isUnset: { $0._supportedFeatures == nil }),
+    .singularInt32({ $0.minimumEdition }, fieldNumber: 3, isUnset: { $0._minimumEdition == nil }),
+    .singularInt32({ $0.maximumEdition }, fieldNumber: 4, isUnset: { $0._maximumEdition == nil }),
+    .repeatedMessage({ $0.file }, fieldNumber: 15),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Compiler_CodeGeneratorResponse, rhs: Google_Protobuf_Compiler_CodeGeneratorResponse) -> Bool {
     if lhs._error != rhs._error {return false}
@@ -581,25 +541,13 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse.File: SwiftProtobuf.Mes
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._name {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._insertionPoint {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._content {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 15)
-    } }()
-    try { if let v = self._generatedCodeInfo {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 16)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
+    .singularString({ $0.insertionPoint }, fieldNumber: 2, isUnset: { $0._insertionPoint == nil }),
+    .singularString({ $0.content }, fieldNumber: 15, isUnset: { $0._content == nil }),
+    .singularMessage({ $0.generatedCodeInfo }, fieldNumber: 16, isUnset: { $0._generatedCodeInfo == nil }),
+  ]
+
 
   public static func ==(lhs: Google_Protobuf_Compiler_CodeGeneratorResponse.File, rhs: Google_Protobuf_Compiler_CodeGeneratorResponse.File) -> Bool {
     if lhs._name != rhs._name {return false}
diff --git a/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift b/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift
index 4becceafe..408e8255e 100644
--- a/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift
+++ b/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift
@@ -89,12 +89,10 @@ extension SwiftProtobuf_GenSwift_ModuleMappings: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.mapping.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.mapping, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.mapping }, fieldNumber: 1),
+  ]
+
 
   public static func ==(lhs: SwiftProtobuf_GenSwift_ModuleMappings, rhs: SwiftProtobuf_GenSwift_ModuleMappings) -> Bool {
     if lhs.mapping != rhs.mapping {return false}
@@ -123,15 +121,11 @@ extension SwiftProtobuf_GenSwift_ModuleMappings.Entry: SwiftProtobuf.Message, Sw
     }
   }
 
-  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.moduleName.isEmpty {
-      try visitor.visitSingularStringField(value: self.moduleName, fieldNumber: 1)
-    }
-    if !self.protoFilePath.isEmpty {
-      try visitor.visitRepeatedStringField(value: self.protoFilePath, fieldNumber: 2)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  public static let _fields: [Field<Self>] = [
+    .singularString({ $0.moduleName }, fieldNumber: 1),
+    .repeatedString({ $0.protoFilePath }, fieldNumber: 2),
+  ]
+
 
   public static func ==(lhs: SwiftProtobuf_GenSwift_ModuleMappings.Entry, rhs: SwiftProtobuf_GenSwift_ModuleMappings.Entry) -> Bool {
     if lhs.moduleName != rhs.moduleName {return false}
diff --git a/Tests/SwiftProtobufTests/Test_Any.swift b/Tests/SwiftProtobufTests/Test_Any.swift
index 602c81ac5..4f6b906da 100644
--- a/Tests/SwiftProtobufTests/Test_Any.swift
+++ b/Tests/SwiftProtobufTests/Test_Any.swift
@@ -828,7 +828,8 @@ struct ConflictingImportMessage:
     SwiftProtobuf.Message,
     SwiftProtobuf._MessageImplementationBase,
     SwiftProtobuf._ProtoNameProviding,
-    @unchecked Sendable {  // Once swift(>=5.9) the '@unchecked' can be removed, it is needed for Data on linux.
+    @unchecked Sendable {
+    // Once swift(>=5.9) the '@unchecked' can be removed, it is needed for Data on linux.
   static let protoMessageName: String = "swift_proto_testing.import.ImportMessage"
 
   var unknownFields = SwiftProtobuf.UnknownStorage()
@@ -840,9 +841,7 @@ struct ConflictingImportMessage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<ConflictingImportMessage>] = []
 
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = SwiftProtobuf._NameMap()
 
diff --git a/Tests/SwiftProtobufTests/any_test.pb.swift b/Tests/SwiftProtobufTests/any_test.pb.swift
index 616aaa054..c1665b3e9 100644
--- a/Tests/SwiftProtobufTests/any_test.pb.swift
+++ b/Tests/SwiftProtobufTests/any_test.pb.swift
@@ -105,25 +105,13 @@ extension SwiftProtoTesting_TestAny: SwiftProtobuf.Message, SwiftProtobuf._Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if self.int32Value != 0 {
-      try visitor.visitSingularInt32Field(value: self.int32Value, fieldNumber: 1)
-    }
-    try { if let v = self._anyValue {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-    } }()
-    if !self.repeatedAnyValue.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.repeatedAnyValue, fieldNumber: 3)
-    }
-    if !self.text.isEmpty {
-      try visitor.visitSingularStringField(value: self.text, fieldNumber: 4)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.int32Value }, fieldNumber: 1),
+    .singularMessage({ $0.anyValue }, fieldNumber: 2, isUnset: { $0._anyValue == nil }),
+    .repeatedMessage({ $0.repeatedAnyValue }, fieldNumber: 3),
+    .singularString({ $0.text }, fieldNumber: 4),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestAny, rhs: SwiftProtoTesting_TestAny) -> Bool {
     if lhs.int32Value != rhs.int32Value {return false}
diff --git a/Tests/SwiftProtobufTests/fuzz_testing.pb.swift b/Tests/SwiftProtobufTests/fuzz_testing.pb.swift
index c4989d82f..ce13fce25 100644
--- a/Tests/SwiftProtobufTests/fuzz_testing.pb.swift
+++ b/Tests/SwiftProtobufTests/fuzz_testing.pb.swift
@@ -3852,862 +3852,325 @@ extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._singularInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._singularInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._singularUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._singularUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._singularSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._singularSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._singularFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._singularFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._singularSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._singularSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._singularFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._singularDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._singularBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._singularString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._singularBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._singularEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._singularGroup {
-        try visitor.visitSingularGroupField(value: v, fieldNumber: 17)
-      } }()
-      try { if let v = _storage._singularMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 19)
-      } }()
-      if !_storage._repeatedInt32.isEmpty {
-        try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31)
-      }
-      if !_storage._repeatedInt64.isEmpty {
-        try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32)
-      }
-      if !_storage._repeatedUint32.isEmpty {
-        try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33)
-      }
-      if !_storage._repeatedUint64.isEmpty {
-        try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34)
-      }
-      if !_storage._repeatedSint32.isEmpty {
-        try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35)
-      }
-      if !_storage._repeatedSint64.isEmpty {
-        try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36)
-      }
-      if !_storage._repeatedFixed32.isEmpty {
-        try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37)
-      }
-      if !_storage._repeatedFixed64.isEmpty {
-        try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38)
-      }
-      if !_storage._repeatedSfixed32.isEmpty {
-        try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39)
-      }
-      if !_storage._repeatedSfixed64.isEmpty {
-        try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40)
-      }
-      if !_storage._repeatedFloat.isEmpty {
-        try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41)
-      }
-      if !_storage._repeatedDouble.isEmpty {
-        try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42)
-      }
-      if !_storage._repeatedBool.isEmpty {
-        try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43)
-      }
-      if !_storage._repeatedString.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44)
-      }
-      if !_storage._repeatedBytes.isEmpty {
-        try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45)
-      }
-      if !_storage._repeatedEnum.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._repeatedEnum, fieldNumber: 46)
-      }
-      if !_storage._repeatedGroup.isEmpty {
-        try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 47)
-      }
-      if !_storage._repeatedMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedMessage, fieldNumber: 49)
-      }
-      switch _storage._o {
-      case .oneofInt32?: try {
-        guard case .oneofInt32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 61)
-      }()
-      case .oneofInt64?: try {
-        guard case .oneofInt64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 62)
-      }()
-      case .oneofUint32?: try {
-        guard case .oneofUint32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63)
-      }()
-      case .oneofUint64?: try {
-        guard case .oneofUint64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64)
-      }()
-      case .oneofSint32?: try {
-        guard case .oneofSint32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65)
-      }()
-      case .oneofSint64?: try {
-        guard case .oneofSint64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66)
-      }()
-      case .oneofFixed32?: try {
-        guard case .oneofFixed32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67)
-      }()
-      case .oneofFixed64?: try {
-        guard case .oneofFixed64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68)
-      }()
-      case .oneofSfixed32?: try {
-        guard case .oneofSfixed32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69)
-      }()
-      case .oneofSfixed64?: try {
-        guard case .oneofSfixed64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70)
-      }()
-      case .oneofFloat?: try {
-        guard case .oneofFloat(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 71)
-      }()
-      case .oneofDouble?: try {
-        guard case .oneofDouble(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 72)
-      }()
-      case .oneofBool?: try {
-        guard case .oneofBool(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 73)
-      }()
-      case .oneofString?: try {
-        guard case .oneofString(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularStringField(value: v, fieldNumber: 74)
-      }()
-      case .oneofBytes?: try {
-        guard case .oneofBytes(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 75)
-      }()
-      case .oneofEnum?: try {
-        guard case .oneofEnum(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 76)
-      }()
-      case .oneofGroup?: try {
-        guard case .oneofGroup(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularGroupField(value: v, fieldNumber: 77)
-      }()
-      case .oneofMessage?: try {
-        guard case .oneofMessage(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 79)
-      }()
-      case nil: break
-      }
-      if !_storage._repeatedPackedInt32.isEmpty {
-        try visitor.visitPackedInt32Field(value: _storage._repeatedPackedInt32, fieldNumber: 81)
-      }
-      if !_storage._repeatedPackedInt64.isEmpty {
-        try visitor.visitPackedInt64Field(value: _storage._repeatedPackedInt64, fieldNumber: 82)
-      }
-      if !_storage._repeatedPackedUint32.isEmpty {
-        try visitor.visitPackedUInt32Field(value: _storage._repeatedPackedUint32, fieldNumber: 83)
-      }
-      if !_storage._repeatedPackedUint64.isEmpty {
-        try visitor.visitPackedUInt64Field(value: _storage._repeatedPackedUint64, fieldNumber: 84)
-      }
-      if !_storage._repeatedPackedSint32.isEmpty {
-        try visitor.visitPackedSInt32Field(value: _storage._repeatedPackedSint32, fieldNumber: 85)
-      }
-      if !_storage._repeatedPackedSint64.isEmpty {
-        try visitor.visitPackedSInt64Field(value: _storage._repeatedPackedSint64, fieldNumber: 86)
-      }
-      if !_storage._repeatedPackedFixed32.isEmpty {
-        try visitor.visitPackedFixed32Field(value: _storage._repeatedPackedFixed32, fieldNumber: 87)
-      }
-      if !_storage._repeatedPackedFixed64.isEmpty {
-        try visitor.visitPackedFixed64Field(value: _storage._repeatedPackedFixed64, fieldNumber: 88)
-      }
-      if !_storage._repeatedPackedSfixed32.isEmpty {
-        try visitor.visitPackedSFixed32Field(value: _storage._repeatedPackedSfixed32, fieldNumber: 89)
-      }
-      if !_storage._repeatedPackedSfixed64.isEmpty {
-        try visitor.visitPackedSFixed64Field(value: _storage._repeatedPackedSfixed64, fieldNumber: 90)
-      }
-      if !_storage._repeatedPackedFloat.isEmpty {
-        try visitor.visitPackedFloatField(value: _storage._repeatedPackedFloat, fieldNumber: 91)
-      }
-      if !_storage._repeatedPackedDouble.isEmpty {
-        try visitor.visitPackedDoubleField(value: _storage._repeatedPackedDouble, fieldNumber: 92)
-      }
-      if !_storage._repeatedPackedBool.isEmpty {
-        try visitor.visitPackedBoolField(value: _storage._repeatedPackedBool, fieldNumber: 93)
-      }
-      if !_storage._repeatedPackedEnum.isEmpty {
-        try visitor.visitPackedEnumField(value: _storage._repeatedPackedEnum, fieldNumber: 94)
-      }
-      if !_storage._mapInt32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapInt32Int32, fieldNumber: 100)
-      }
-      if !_storage._mapInt32Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapInt32Int64, fieldNumber: 101)
-      }
-      if !_storage._mapInt32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapInt32Uint32, fieldNumber: 102)
-      }
-      if !_storage._mapInt32Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapInt32Uint64, fieldNumber: 103)
-      }
-      if !_storage._mapInt32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapInt32Sint32, fieldNumber: 104)
-      }
-      if !_storage._mapInt32Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapInt32Sint64, fieldNumber: 105)
-      }
-      if !_storage._mapInt32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapInt32Fixed32, fieldNumber: 106)
-      }
-      if !_storage._mapInt32Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapInt32Fixed64, fieldNumber: 107)
-      }
-      if !_storage._mapInt32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapInt32Sfixed32, fieldNumber: 108)
-      }
-      if !_storage._mapInt32Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapInt32Sfixed64, fieldNumber: 109)
-      }
-      if !_storage._mapInt32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapInt32Float, fieldNumber: 110)
-      }
-      if !_storage._mapInt32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapInt32Double, fieldNumber: 111)
-      }
-      if !_storage._mapInt32Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapInt32Bool, fieldNumber: 112)
-      }
-      if !_storage._mapInt32String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufString>.self, value: _storage._mapInt32String, fieldNumber: 113)
-      }
-      if !_storage._mapInt32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapInt32Bytes, fieldNumber: 114)
-      }
-      if !_storage._mapInt32AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapInt32AnEnum, fieldNumber: 115)
-      }
-      if !_storage._mapInt32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapInt32Message, fieldNumber: 116)
-      }
-      if !_storage._mapInt64Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapInt64Int32, fieldNumber: 117)
-      }
-      if !_storage._mapInt64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapInt64Int64, fieldNumber: 118)
-      }
-      if !_storage._mapInt64Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapInt64Uint32, fieldNumber: 119)
-      }
-      if !_storage._mapInt64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapInt64Uint64, fieldNumber: 120)
-      }
-      if !_storage._mapInt64Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapInt64Sint32, fieldNumber: 121)
-      }
-      if !_storage._mapInt64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapInt64Sint64, fieldNumber: 122)
-      }
-      if !_storage._mapInt64Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapInt64Fixed32, fieldNumber: 123)
-      }
-      if !_storage._mapInt64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapInt64Fixed64, fieldNumber: 124)
-      }
-      if !_storage._mapInt64Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapInt64Sfixed32, fieldNumber: 125)
-      }
-      if !_storage._mapInt64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapInt64Sfixed64, fieldNumber: 126)
-      }
-      if !_storage._mapInt64Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapInt64Float, fieldNumber: 127)
-      }
-      if !_storage._mapInt64Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapInt64Double, fieldNumber: 128)
-      }
-      if !_storage._mapInt64Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapInt64Bool, fieldNumber: 129)
-      }
-      if !_storage._mapInt64String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufString>.self, value: _storage._mapInt64String, fieldNumber: 130)
-      }
-      if !_storage._mapInt64Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapInt64Bytes, fieldNumber: 131)
-      }
-      if !_storage._mapInt64AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapInt64AnEnum, fieldNumber: 132)
-      }
-      if !_storage._mapInt64Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapInt64Message, fieldNumber: 133)
-      }
-      if !_storage._mapUint32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapUint32Int32, fieldNumber: 134)
-      }
-      if !_storage._mapUint32Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapUint32Int64, fieldNumber: 135)
-      }
-      if !_storage._mapUint32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapUint32Uint32, fieldNumber: 136)
-      }
-      if !_storage._mapUint32Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapUint32Uint64, fieldNumber: 137)
-      }
-      if !_storage._mapUint32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapUint32Sint32, fieldNumber: 138)
-      }
-      if !_storage._mapUint32Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapUint32Sint64, fieldNumber: 139)
-      }
-      if !_storage._mapUint32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapUint32Fixed32, fieldNumber: 140)
-      }
-      if !_storage._mapUint32Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapUint32Fixed64, fieldNumber: 141)
-      }
-      if !_storage._mapUint32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapUint32Sfixed32, fieldNumber: 142)
-      }
-      if !_storage._mapUint32Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapUint32Sfixed64, fieldNumber: 143)
-      }
-      if !_storage._mapUint32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapUint32Float, fieldNumber: 144)
-      }
-      if !_storage._mapUint32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapUint32Double, fieldNumber: 145)
-      }
-      if !_storage._mapUint32Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapUint32Bool, fieldNumber: 146)
-      }
-      if !_storage._mapUint32String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufString>.self, value: _storage._mapUint32String, fieldNumber: 147)
-      }
-      if !_storage._mapUint32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapUint32Bytes, fieldNumber: 148)
-      }
-      if !_storage._mapUint32AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapUint32AnEnum, fieldNumber: 149)
-      }
-      if !_storage._mapUint32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapUint32Message, fieldNumber: 150)
-      }
-      if !_storage._mapUint64Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapUint64Int32, fieldNumber: 151)
-      }
-      if !_storage._mapUint64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapUint64Int64, fieldNumber: 152)
-      }
-      if !_storage._mapUint64Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapUint64Uint32, fieldNumber: 153)
-      }
-      if !_storage._mapUint64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapUint64Uint64, fieldNumber: 154)
-      }
-      if !_storage._mapUint64Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapUint64Sint32, fieldNumber: 155)
-      }
-      if !_storage._mapUint64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapUint64Sint64, fieldNumber: 156)
-      }
-      if !_storage._mapUint64Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapUint64Fixed32, fieldNumber: 157)
-      }
-      if !_storage._mapUint64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapUint64Fixed64, fieldNumber: 158)
-      }
-      if !_storage._mapUint64Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapUint64Sfixed32, fieldNumber: 159)
-      }
-      if !_storage._mapUint64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapUint64Sfixed64, fieldNumber: 160)
-      }
-      if !_storage._mapUint64Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapUint64Float, fieldNumber: 161)
-      }
-      if !_storage._mapUint64Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapUint64Double, fieldNumber: 162)
-      }
-      if !_storage._mapUint64Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapUint64Bool, fieldNumber: 163)
-      }
-      if !_storage._mapUint64String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufString>.self, value: _storage._mapUint64String, fieldNumber: 164)
-      }
-      if !_storage._mapUint64Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapUint64Bytes, fieldNumber: 165)
-      }
-      if !_storage._mapUint64AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapUint64AnEnum, fieldNumber: 166)
-      }
-      if !_storage._mapUint64Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapUint64Message, fieldNumber: 167)
-      }
-      if !_storage._mapSint32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapSint32Int32, fieldNumber: 168)
-      }
-      if !_storage._mapSint32Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapSint32Int64, fieldNumber: 169)
-      }
-      if !_storage._mapSint32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapSint32Uint32, fieldNumber: 170)
-      }
-      if !_storage._mapSint32Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapSint32Uint64, fieldNumber: 171)
-      }
-      if !_storage._mapSint32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSint32Sint32, fieldNumber: 172)
-      }
-      if !_storage._mapSint32Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSint32Sint64, fieldNumber: 173)
-      }
-      if !_storage._mapSint32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapSint32Fixed32, fieldNumber: 174)
-      }
-      if !_storage._mapSint32Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapSint32Fixed64, fieldNumber: 175)
-      }
-      if !_storage._mapSint32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSint32Sfixed32, fieldNumber: 176)
-      }
-      if !_storage._mapSint32Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSint32Sfixed64, fieldNumber: 177)
-      }
-      if !_storage._mapSint32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapSint32Float, fieldNumber: 178)
-      }
-      if !_storage._mapSint32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapSint32Double, fieldNumber: 179)
-      }
-      if !_storage._mapSint32Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapSint32Bool, fieldNumber: 180)
-      }
-      if !_storage._mapSint32String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufString>.self, value: _storage._mapSint32String, fieldNumber: 181)
-      }
-      if !_storage._mapSint32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapSint32Bytes, fieldNumber: 182)
-      }
-      if !_storage._mapSint32AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapSint32AnEnum, fieldNumber: 183)
-      }
-      if !_storage._mapSint32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapSint32Message, fieldNumber: 184)
-      }
-      if !_storage._mapSint64Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapSint64Int32, fieldNumber: 185)
-      }
-      if !_storage._mapSint64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapSint64Int64, fieldNumber: 186)
-      }
-      if !_storage._mapSint64Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapSint64Uint32, fieldNumber: 187)
-      }
-      if !_storage._mapSint64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapSint64Uint64, fieldNumber: 188)
-      }
-      if !_storage._mapSint64Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSint64Sint32, fieldNumber: 189)
-      }
-      if !_storage._mapSint64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSint64Sint64, fieldNumber: 190)
-      }
-      if !_storage._mapSint64Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapSint64Fixed32, fieldNumber: 191)
-      }
-      if !_storage._mapSint64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapSint64Fixed64, fieldNumber: 192)
-      }
-      if !_storage._mapSint64Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSint64Sfixed32, fieldNumber: 193)
-      }
-      if !_storage._mapSint64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSint64Sfixed64, fieldNumber: 194)
-      }
-      if !_storage._mapSint64Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapSint64Float, fieldNumber: 195)
-      }
-      if !_storage._mapSint64Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapSint64Double, fieldNumber: 196)
-      }
-      if !_storage._mapSint64Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapSint64Bool, fieldNumber: 197)
-      }
-      if !_storage._mapSint64String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufString>.self, value: _storage._mapSint64String, fieldNumber: 198)
-      }
-      if !_storage._mapSint64Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapSint64Bytes, fieldNumber: 199)
-      }
-      if !_storage._mapSint64AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapSint64AnEnum, fieldNumber: 200)
-      }
-      if !_storage._mapSint64Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapSint64Message, fieldNumber: 201)
-      }
-      if !_storage._mapFixed32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapFixed32Int32, fieldNumber: 202)
-      }
-      if !_storage._mapFixed32Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapFixed32Int64, fieldNumber: 203)
-      }
-      if !_storage._mapFixed32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapFixed32Uint32, fieldNumber: 204)
-      }
-      if !_storage._mapFixed32Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapFixed32Uint64, fieldNumber: 205)
-      }
-      if !_storage._mapFixed32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapFixed32Sint32, fieldNumber: 206)
-      }
-      if !_storage._mapFixed32Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapFixed32Sint64, fieldNumber: 207)
-      }
-      if !_storage._mapFixed32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapFixed32Fixed32, fieldNumber: 208)
-      }
-      if !_storage._mapFixed32Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapFixed32Fixed64, fieldNumber: 209)
-      }
-      if !_storage._mapFixed32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapFixed32Sfixed32, fieldNumber: 210)
-      }
-      if !_storage._mapFixed32Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapFixed32Sfixed64, fieldNumber: 211)
-      }
-      if !_storage._mapFixed32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapFixed32Float, fieldNumber: 212)
-      }
-      if !_storage._mapFixed32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapFixed32Double, fieldNumber: 213)
-      }
-      if !_storage._mapFixed32Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapFixed32Bool, fieldNumber: 214)
-      }
-      if !_storage._mapFixed32String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufString>.self, value: _storage._mapFixed32String, fieldNumber: 215)
-      }
-      if !_storage._mapFixed32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapFixed32Bytes, fieldNumber: 216)
-      }
-      if !_storage._mapFixed32AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapFixed32AnEnum, fieldNumber: 217)
-      }
-      if !_storage._mapFixed32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapFixed32Message, fieldNumber: 218)
-      }
-      if !_storage._mapFixed64Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapFixed64Int32, fieldNumber: 219)
-      }
-      if !_storage._mapFixed64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapFixed64Int64, fieldNumber: 220)
-      }
-      if !_storage._mapFixed64Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapFixed64Uint32, fieldNumber: 221)
-      }
-      if !_storage._mapFixed64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapFixed64Uint64, fieldNumber: 222)
-      }
-      if !_storage._mapFixed64Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapFixed64Sint32, fieldNumber: 223)
-      }
-      if !_storage._mapFixed64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapFixed64Sint64, fieldNumber: 224)
-      }
-      if !_storage._mapFixed64Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapFixed64Fixed32, fieldNumber: 225)
-      }
-      if !_storage._mapFixed64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapFixed64Fixed64, fieldNumber: 226)
-      }
-      if !_storage._mapFixed64Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapFixed64Sfixed32, fieldNumber: 227)
-      }
-      if !_storage._mapFixed64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapFixed64Sfixed64, fieldNumber: 228)
-      }
-      if !_storage._mapFixed64Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapFixed64Float, fieldNumber: 229)
-      }
-      if !_storage._mapFixed64Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapFixed64Double, fieldNumber: 230)
-      }
-      if !_storage._mapFixed64Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapFixed64Bool, fieldNumber: 231)
-      }
-      if !_storage._mapFixed64String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufString>.self, value: _storage._mapFixed64String, fieldNumber: 232)
-      }
-      if !_storage._mapFixed64Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapFixed64Bytes, fieldNumber: 233)
-      }
-      if !_storage._mapFixed64AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapFixed64AnEnum, fieldNumber: 234)
-      }
-      if !_storage._mapFixed64Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapFixed64Message, fieldNumber: 235)
-      }
-      if !_storage._mapSfixed32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapSfixed32Int32, fieldNumber: 236)
-      }
-      if !_storage._mapSfixed32Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapSfixed32Int64, fieldNumber: 237)
-      }
-      if !_storage._mapSfixed32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapSfixed32Uint32, fieldNumber: 238)
-      }
-      if !_storage._mapSfixed32Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapSfixed32Uint64, fieldNumber: 239)
-      }
-      if !_storage._mapSfixed32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSfixed32Sint32, fieldNumber: 240)
-      }
-      if !_storage._mapSfixed32Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSfixed32Sint64, fieldNumber: 241)
-      }
-      if !_storage._mapSfixed32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapSfixed32Fixed32, fieldNumber: 242)
-      }
-      if !_storage._mapSfixed32Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapSfixed32Fixed64, fieldNumber: 243)
-      }
-      if !_storage._mapSfixed32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 244)
-      }
-      if !_storage._mapSfixed32Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSfixed32Sfixed64, fieldNumber: 245)
-      }
-      if !_storage._mapSfixed32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapSfixed32Float, fieldNumber: 246)
-      }
-      if !_storage._mapSfixed32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapSfixed32Double, fieldNumber: 247)
-      }
-      if !_storage._mapSfixed32Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapSfixed32Bool, fieldNumber: 248)
-      }
-      if !_storage._mapSfixed32String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufString>.self, value: _storage._mapSfixed32String, fieldNumber: 249)
-      }
-      if !_storage._mapSfixed32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapSfixed32Bytes, fieldNumber: 250)
-      }
-      if !_storage._mapSfixed32AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapSfixed32AnEnum, fieldNumber: 251)
-      }
-      if !_storage._mapSfixed32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapSfixed32Message, fieldNumber: 252)
-      }
-      if !_storage._mapSfixed64Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapSfixed64Int32, fieldNumber: 253)
-      }
-      if !_storage._mapSfixed64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapSfixed64Int64, fieldNumber: 254)
-      }
-      if !_storage._mapSfixed64Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapSfixed64Uint32, fieldNumber: 255)
-      }
-      if !_storage._mapSfixed64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapSfixed64Uint64, fieldNumber: 256)
-      }
-      if !_storage._mapSfixed64Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSfixed64Sint32, fieldNumber: 257)
-      }
-      if !_storage._mapSfixed64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSfixed64Sint64, fieldNumber: 258)
-      }
-      if !_storage._mapSfixed64Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapSfixed64Fixed32, fieldNumber: 259)
-      }
-      if !_storage._mapSfixed64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapSfixed64Fixed64, fieldNumber: 260)
-      }
-      if !_storage._mapSfixed64Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSfixed64Sfixed32, fieldNumber: 261)
-      }
-      if !_storage._mapSfixed64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 262)
-      }
-      if !_storage._mapSfixed64Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapSfixed64Float, fieldNumber: 263)
-      }
-      if !_storage._mapSfixed64Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapSfixed64Double, fieldNumber: 264)
-      }
-      if !_storage._mapSfixed64Bool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapSfixed64Bool, fieldNumber: 265)
-      }
-      if !_storage._mapSfixed64String.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufString>.self, value: _storage._mapSfixed64String, fieldNumber: 266)
-      }
-      if !_storage._mapSfixed64Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapSfixed64Bytes, fieldNumber: 267)
-      }
-      if !_storage._mapSfixed64AnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapSfixed64AnEnum, fieldNumber: 268)
-      }
-      if !_storage._mapSfixed64Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapSfixed64Message, fieldNumber: 269)
-      }
-      if !_storage._mapBoolInt32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapBoolInt32, fieldNumber: 270)
-      }
-      if !_storage._mapBoolInt64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapBoolInt64, fieldNumber: 271)
-      }
-      if !_storage._mapBoolUint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapBoolUint32, fieldNumber: 272)
-      }
-      if !_storage._mapBoolUint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapBoolUint64, fieldNumber: 273)
-      }
-      if !_storage._mapBoolSint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapBoolSint32, fieldNumber: 274)
-      }
-      if !_storage._mapBoolSint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapBoolSint64, fieldNumber: 275)
-      }
-      if !_storage._mapBoolFixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapBoolFixed32, fieldNumber: 276)
-      }
-      if !_storage._mapBoolFixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapBoolFixed64, fieldNumber: 277)
-      }
-      if !_storage._mapBoolSfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapBoolSfixed32, fieldNumber: 278)
-      }
-      if !_storage._mapBoolSfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapBoolSfixed64, fieldNumber: 279)
-      }
-      if !_storage._mapBoolFloat.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapBoolFloat, fieldNumber: 280)
-      }
-      if !_storage._mapBoolDouble.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapBoolDouble, fieldNumber: 281)
-      }
-      if !_storage._mapBoolBool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapBoolBool, fieldNumber: 282)
-      }
-      if !_storage._mapBoolString.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufString>.self, value: _storage._mapBoolString, fieldNumber: 283)
-      }
-      if !_storage._mapBoolBytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapBoolBytes, fieldNumber: 284)
-      }
-      if !_storage._mapBoolAnEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_AnEnum>.self, value: _storage._mapBoolAnEnum, fieldNumber: 285)
-      }
-      if !_storage._mapBoolMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_Message>.self, value: _storage._mapBoolMessage, fieldNumber: 286)
-      }
-      try { if let v = _storage._wktAny {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 500)
-      } }()
-      try { if let v = _storage._wktApi {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 501)
-      } }()
-      try { if let v = _storage._wktDuration {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 502)
-      } }()
-      try { if let v = _storage._wktEmpty {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 503)
-      } }()
-      try { if let v = _storage._wktFieldMask {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 504)
-      } }()
-      try { if let v = _storage._wktSourceContext {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 505)
-      } }()
-      try { if let v = _storage._wktStruct {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 506)
-      } }()
-      try { if let v = _storage._wktTimestamp {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 507)
-      } }()
-      try { if let v = _storage._wktType {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 508)
-      } }()
-      try { if let v = _storage._wktDoubleValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 509)
-      } }()
-      try { if let v = _storage._wktFloatValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 510)
-      } }()
-      try { if let v = _storage._wktInt64Value {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 511)
-      } }()
-      try { if let v = _storage._wktUint64Value {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 512)
-      } }()
-      try { if let v = _storage._wktInt32Value {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 513)
-      } }()
-      try { if let v = _storage._wktUint32Value {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 514)
-      } }()
-      try { if let v = _storage._wktBoolValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 515)
-      } }()
-      try { if let v = _storage._wktStringValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 516)
-      } }()
-      try { if let v = _storage._wktBytesValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 517)
-      } }()
-      try { if let v = _storage._singularMessageSet {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 600)
-      } }()
-      if !_storage._repeatedMessageSet.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedMessageSet, fieldNumber: 601)
-      }
-      try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 2001)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularInt32 }, fieldNumber: 1, isUnset: { $0._storage._singularInt32 == nil }),
+    .singularInt64({ $0.singularInt64 }, fieldNumber: 2, isUnset: { $0._storage._singularInt64 == nil }),
+    .singularUInt32({ $0.singularUint32 }, fieldNumber: 3, isUnset: { $0._storage._singularUint32 == nil }),
+    .singularUInt64({ $0.singularUint64 }, fieldNumber: 4, isUnset: { $0._storage._singularUint64 == nil }),
+    .singularSInt32({ $0.singularSint32 }, fieldNumber: 5, isUnset: { $0._storage._singularSint32 == nil }),
+    .singularSInt64({ $0.singularSint64 }, fieldNumber: 6, isUnset: { $0._storage._singularSint64 == nil }),
+    .singularFixed32({ $0.singularFixed32 }, fieldNumber: 7, isUnset: { $0._storage._singularFixed32 == nil }),
+    .singularFixed64({ $0.singularFixed64 }, fieldNumber: 8, isUnset: { $0._storage._singularFixed64 == nil }),
+    .singularSFixed32({ $0.singularSfixed32 }, fieldNumber: 9, isUnset: { $0._storage._singularSfixed32 == nil }),
+    .singularSFixed64({ $0.singularSfixed64 }, fieldNumber: 10, isUnset: { $0._storage._singularSfixed64 == nil }),
+    .singularFloat({ $0.singularFloat }, fieldNumber: 11, isUnset: { $0._storage._singularFloat == nil }),
+    .singularDouble({ $0.singularDouble }, fieldNumber: 12, isUnset: { $0._storage._singularDouble == nil }),
+    .singularBool({ $0.singularBool }, fieldNumber: 13, isUnset: { $0._storage._singularBool == nil }),
+    .singularString({ $0.singularString }, fieldNumber: 14, isUnset: { $0._storage._singularString == nil }),
+    .singularBytes({ $0.singularBytes }, fieldNumber: 15, isUnset: { $0._storage._singularBytes == nil }),
+    .singularEnum({ $0.singularEnum }, fieldNumber: 16, isUnset: { $0._storage._singularEnum == nil }),
+    .singularGroup({ $0.singularGroup }, fieldNumber: 17, isUnset: { $0._storage._singularGroup == nil }),
+    .singularMessage({ $0.singularMessage }, fieldNumber: 19, isUnset: { $0._storage._singularMessage == nil }),
+    .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
+    .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
+    .repeatedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
+    .repeatedUInt64({ $0.repeatedUint64 }, fieldNumber: 34),
+    .repeatedSInt32({ $0.repeatedSint32 }, fieldNumber: 35),
+    .repeatedSInt64({ $0.repeatedSint64 }, fieldNumber: 36),
+    .repeatedFixed32({ $0.repeatedFixed32 }, fieldNumber: 37),
+    .repeatedFixed64({ $0.repeatedFixed64 }, fieldNumber: 38),
+    .repeatedSFixed32({ $0.repeatedSfixed32 }, fieldNumber: 39),
+    .repeatedSFixed64({ $0.repeatedSfixed64 }, fieldNumber: 40),
+    .repeatedFloat({ $0.repeatedFloat }, fieldNumber: 41),
+    .repeatedDouble({ $0.repeatedDouble }, fieldNumber: 42),
+    .repeatedBool({ $0.repeatedBool }, fieldNumber: 43),
+    .repeatedString({ $0.repeatedString }, fieldNumber: 44),
+    .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
+    .repeatedEnum({ $0.repeatedEnum }, fieldNumber: 46),
+    .repeatedGroup({ $0.repeatedGroup }, fieldNumber: 47),
+    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 49),
+    .oneOf({ $0.o }) {
+      switch $0 {
+      case .oneofInt32:
+        return _oneOfField_oneofInt32
+      case .oneofInt64:
+        return _oneOfField_oneofInt64
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofUint64:
+        return _oneOfField_oneofUint64
+      case .oneofSint32:
+        return _oneOfField_oneofSint32
+      case .oneofSint64:
+        return _oneOfField_oneofSint64
+      case .oneofFixed32:
+        return _oneOfField_oneofFixed32
+      case .oneofFixed64:
+        return _oneOfField_oneofFixed64
+      case .oneofSfixed32:
+        return _oneOfField_oneofSfixed32
+      case .oneofSfixed64:
+        return _oneOfField_oneofSfixed64
+      case .oneofFloat:
+        return _oneOfField_oneofFloat
+      case .oneofDouble:
+        return _oneOfField_oneofDouble
+      case .oneofBool:
+        return _oneOfField_oneofBool
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
+      case .oneofEnum:
+        return _oneOfField_oneofEnum
+      case .oneofGroup:
+        return _oneOfField_oneofGroup
+      case .oneofMessage:
+        return _oneOfField_oneofMessage
+      }
+    },
+    .packedInt32({ $0.repeatedPackedInt32 }, fieldNumber: 81),
+    .packedInt64({ $0.repeatedPackedInt64 }, fieldNumber: 82),
+    .packedUInt32({ $0.repeatedPackedUint32 }, fieldNumber: 83),
+    .packedUInt64({ $0.repeatedPackedUint64 }, fieldNumber: 84),
+    .packedSInt32({ $0.repeatedPackedSint32 }, fieldNumber: 85),
+    .packedSInt64({ $0.repeatedPackedSint64 }, fieldNumber: 86),
+    .packedFixed32({ $0.repeatedPackedFixed32 }, fieldNumber: 87),
+    .packedFixed64({ $0.repeatedPackedFixed64 }, fieldNumber: 88),
+    .packedSFixed32({ $0.repeatedPackedSfixed32 }, fieldNumber: 89),
+    .packedSFixed64({ $0.repeatedPackedSfixed64 }, fieldNumber: 90),
+    .packedFloat({ $0.repeatedPackedFloat }, fieldNumber: 91),
+    .packedDouble({ $0.repeatedPackedDouble }, fieldNumber: 92),
+    .packedBool({ $0.repeatedPackedBool }, fieldNumber: 93),
+    .packedEnum({ $0.repeatedPackedEnum }, fieldNumber: 94),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 100),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt32Int64 }, fieldNumber: 101),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapInt32Uint32 }, fieldNumber: 102),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapInt32Uint64 }, fieldNumber: 103),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapInt32Sint32 }, fieldNumber: 104),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapInt32Sint64 }, fieldNumber: 105),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapInt32Fixed32 }, fieldNumber: 106),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapInt32Fixed64 }, fieldNumber: 107),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapInt32Sfixed32 }, fieldNumber: 108),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapInt32Sfixed64 }, fieldNumber: 109),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 110),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 111),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapInt32Bool }, fieldNumber: 112),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapInt32String }, fieldNumber: 113),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt32Bytes }, fieldNumber: 114),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapInt32AnEnum }, fieldNumber: 115),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapInt32Message }, fieldNumber: 116),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt64Int32 }, fieldNumber: 117),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 118),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapInt64Uint32 }, fieldNumber: 119),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapInt64Uint64 }, fieldNumber: 120),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapInt64Sint32 }, fieldNumber: 121),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapInt64Sint64 }, fieldNumber: 122),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapInt64Fixed32 }, fieldNumber: 123),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapInt64Fixed64 }, fieldNumber: 124),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapInt64Sfixed32 }, fieldNumber: 125),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapInt64Sfixed64 }, fieldNumber: 126),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt64Float }, fieldNumber: 127),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt64Double }, fieldNumber: 128),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapInt64Bool }, fieldNumber: 129),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapInt64String }, fieldNumber: 130),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt64Bytes }, fieldNumber: 131),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapInt64AnEnum }, fieldNumber: 132),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapInt64Message }, fieldNumber: 133),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapUint32Int32 }, fieldNumber: 134),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapUint32Int64 }, fieldNumber: 135),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 136),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint32Uint64 }, fieldNumber: 137),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapUint32Sint32 }, fieldNumber: 138),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapUint32Sint64 }, fieldNumber: 139),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapUint32Fixed32 }, fieldNumber: 140),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapUint32Fixed64 }, fieldNumber: 141),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapUint32Sfixed32 }, fieldNumber: 142),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapUint32Sfixed64 }, fieldNumber: 143),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapUint32Float }, fieldNumber: 144),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapUint32Double }, fieldNumber: 145),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapUint32Bool }, fieldNumber: 146),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapUint32String }, fieldNumber: 147),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapUint32Bytes }, fieldNumber: 148),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapUint32AnEnum }, fieldNumber: 149),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapUint32Message }, fieldNumber: 150),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapUint64Int32 }, fieldNumber: 151),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapUint64Int64 }, fieldNumber: 152),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint64Uint32 }, fieldNumber: 153),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 154),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapUint64Sint32 }, fieldNumber: 155),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapUint64Sint64 }, fieldNumber: 156),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapUint64Fixed32 }, fieldNumber: 157),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapUint64Fixed64 }, fieldNumber: 158),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapUint64Sfixed32 }, fieldNumber: 159),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapUint64Sfixed64 }, fieldNumber: 160),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapUint64Float }, fieldNumber: 161),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapUint64Double }, fieldNumber: 162),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapUint64Bool }, fieldNumber: 163),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapUint64String }, fieldNumber: 164),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapUint64Bytes }, fieldNumber: 165),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapUint64AnEnum }, fieldNumber: 166),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapUint64Message }, fieldNumber: 167),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSint32Int32 }, fieldNumber: 168),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSint32Int64 }, fieldNumber: 169),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSint32Uint32 }, fieldNumber: 170),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSint32Uint64 }, fieldNumber: 171),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 172),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint32Sint64 }, fieldNumber: 173),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSint32Fixed32 }, fieldNumber: 174),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSint32Fixed64 }, fieldNumber: 175),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSint32Sfixed32 }, fieldNumber: 176),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSint32Sfixed64 }, fieldNumber: 177),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSint32Float }, fieldNumber: 178),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSint32Double }, fieldNumber: 179),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapSint32Bool }, fieldNumber: 180),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapSint32String }, fieldNumber: 181),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSint32Bytes }, fieldNumber: 182),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSint32AnEnum }, fieldNumber: 183),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSint32Message }, fieldNumber: 184),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSint64Int32 }, fieldNumber: 185),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSint64Int64 }, fieldNumber: 186),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSint64Uint32 }, fieldNumber: 187),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSint64Uint64 }, fieldNumber: 188),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint64Sint32 }, fieldNumber: 189),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 190),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSint64Fixed32 }, fieldNumber: 191),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSint64Fixed64 }, fieldNumber: 192),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSint64Sfixed32 }, fieldNumber: 193),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSint64Sfixed64 }, fieldNumber: 194),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSint64Float }, fieldNumber: 195),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSint64Double }, fieldNumber: 196),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapSint64Bool }, fieldNumber: 197),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapSint64String }, fieldNumber: 198),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSint64Bytes }, fieldNumber: 199),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSint64AnEnum }, fieldNumber: 200),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSint64Message }, fieldNumber: 201),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapFixed32Int32 }, fieldNumber: 202),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapFixed32Int64 }, fieldNumber: 203),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapFixed32Uint32 }, fieldNumber: 204),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapFixed32Uint64 }, fieldNumber: 205),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapFixed32Sint32 }, fieldNumber: 206),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapFixed32Sint64 }, fieldNumber: 207),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 208),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed32Fixed64 }, fieldNumber: 209),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapFixed32Sfixed32 }, fieldNumber: 210),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapFixed32Sfixed64 }, fieldNumber: 211),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapFixed32Float }, fieldNumber: 212),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapFixed32Double }, fieldNumber: 213),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBool>.self, { $0.mapFixed32Bool }, fieldNumber: 214),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufString>.self, { $0.mapFixed32String }, fieldNumber: 215),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapFixed32Bytes }, fieldNumber: 216),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapFixed32AnEnum }, fieldNumber: 217),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapFixed32Message }, fieldNumber: 218),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapFixed64Int32 }, fieldNumber: 219),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapFixed64Int64 }, fieldNumber: 220),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapFixed64Uint32 }, fieldNumber: 221),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapFixed64Uint64 }, fieldNumber: 222),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapFixed64Sint32 }, fieldNumber: 223),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapFixed64Sint64 }, fieldNumber: 224),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed64Fixed32 }, fieldNumber: 225),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 226),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapFixed64Sfixed32 }, fieldNumber: 227),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapFixed64Sfixed64 }, fieldNumber: 228),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapFixed64Float }, fieldNumber: 229),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapFixed64Double }, fieldNumber: 230),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBool>.self, { $0.mapFixed64Bool }, fieldNumber: 231),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufString>.self, { $0.mapFixed64String }, fieldNumber: 232),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapFixed64Bytes }, fieldNumber: 233),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapFixed64AnEnum }, fieldNumber: 234),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapFixed64Message }, fieldNumber: 235),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSfixed32Int32 }, fieldNumber: 236),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSfixed32Int64 }, fieldNumber: 237),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSfixed32Uint32 }, fieldNumber: 238),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSfixed32Uint64 }, fieldNumber: 239),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSfixed32Sint32 }, fieldNumber: 240),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSfixed32Sint64 }, fieldNumber: 241),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSfixed32Fixed32 }, fieldNumber: 242),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSfixed32Fixed64 }, fieldNumber: 243),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 244),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed32Sfixed64 }, fieldNumber: 245),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSfixed32Float }, fieldNumber: 246),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSfixed32Double }, fieldNumber: 247),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBool>.self, { $0.mapSfixed32Bool }, fieldNumber: 248),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufString>.self, { $0.mapSfixed32String }, fieldNumber: 249),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSfixed32Bytes }, fieldNumber: 250),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSfixed32AnEnum }, fieldNumber: 251),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSfixed32Message }, fieldNumber: 252),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSfixed64Int32 }, fieldNumber: 253),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSfixed64Int64 }, fieldNumber: 254),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSfixed64Uint32 }, fieldNumber: 255),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSfixed64Uint64 }, fieldNumber: 256),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSfixed64Sint32 }, fieldNumber: 257),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSfixed64Sint64 }, fieldNumber: 258),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSfixed64Fixed32 }, fieldNumber: 259),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSfixed64Fixed64 }, fieldNumber: 260),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed64Sfixed32 }, fieldNumber: 261),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 262),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSfixed64Float }, fieldNumber: 263),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSfixed64Double }, fieldNumber: 264),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBool>.self, { $0.mapSfixed64Bool }, fieldNumber: 265),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufString>.self, { $0.mapSfixed64String }, fieldNumber: 266),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSfixed64Bytes }, fieldNumber: 267),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSfixed64AnEnum }, fieldNumber: 268),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSfixed64Message }, fieldNumber: 269),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt32>.self, { $0.mapBoolInt32 }, fieldNumber: 270),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt64>.self, { $0.mapBoolInt64 }, fieldNumber: 271),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapBoolUint32 }, fieldNumber: 272),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapBoolUint64 }, fieldNumber: 273),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapBoolSint32 }, fieldNumber: 274),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapBoolSint64 }, fieldNumber: 275),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapBoolFixed32 }, fieldNumber: 276),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapBoolFixed64 }, fieldNumber: 277),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapBoolSfixed32 }, fieldNumber: 278),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapBoolSfixed64 }, fieldNumber: 279),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFloat>.self, { $0.mapBoolFloat }, fieldNumber: 280),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufDouble>.self, { $0.mapBoolDouble }, fieldNumber: 281),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 282),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufString>.self, { $0.mapBoolString }, fieldNumber: 283),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBytes>.self, { $0.mapBoolBytes }, fieldNumber: 284),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapBoolAnEnum }, fieldNumber: 285),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapBoolMessage }, fieldNumber: 286),
+    .singularMessage({ $0.wktAny }, fieldNumber: 500, isUnset: { $0._storage._wktAny == nil }),
+    .singularMessage({ $0.wktApi }, fieldNumber: 501, isUnset: { $0._storage._wktApi == nil }),
+    .singularMessage({ $0.wktDuration }, fieldNumber: 502, isUnset: { $0._storage._wktDuration == nil }),
+    .singularMessage({ $0.wktEmpty }, fieldNumber: 503, isUnset: { $0._storage._wktEmpty == nil }),
+    .singularMessage({ $0.wktFieldMask }, fieldNumber: 504, isUnset: { $0._storage._wktFieldMask == nil }),
+    .singularMessage({ $0.wktSourceContext }, fieldNumber: 505, isUnset: { $0._storage._wktSourceContext == nil }),
+    .singularMessage({ $0.wktStruct }, fieldNumber: 506, isUnset: { $0._storage._wktStruct == nil }),
+    .singularMessage({ $0.wktTimestamp }, fieldNumber: 507, isUnset: { $0._storage._wktTimestamp == nil }),
+    .singularMessage({ $0.wktType }, fieldNumber: 508, isUnset: { $0._storage._wktType == nil }),
+    .singularMessage({ $0.wktDoubleValue }, fieldNumber: 509, isUnset: { $0._storage._wktDoubleValue == nil }),
+    .singularMessage({ $0.wktFloatValue }, fieldNumber: 510, isUnset: { $0._storage._wktFloatValue == nil }),
+    .singularMessage({ $0.wktInt64Value }, fieldNumber: 511, isUnset: { $0._storage._wktInt64Value == nil }),
+    .singularMessage({ $0.wktUint64Value }, fieldNumber: 512, isUnset: { $0._storage._wktUint64Value == nil }),
+    .singularMessage({ $0.wktInt32Value }, fieldNumber: 513, isUnset: { $0._storage._wktInt32Value == nil }),
+    .singularMessage({ $0.wktUint32Value }, fieldNumber: 514, isUnset: { $0._storage._wktUint32Value == nil }),
+    .singularMessage({ $0.wktBoolValue }, fieldNumber: 515, isUnset: { $0._storage._wktBoolValue == nil }),
+    .singularMessage({ $0.wktStringValue }, fieldNumber: 516, isUnset: { $0._storage._wktStringValue == nil }),
+    .singularMessage({ $0.wktBytesValue }, fieldNumber: 517, isUnset: { $0._storage._wktBytesValue == nil }),
+    .singularMessage({ $0.singularMessageSet }, fieldNumber: 600, isUnset: { $0._storage._singularMessageSet == nil }),
+    .repeatedMessage({ $0.repeatedMessageSet }, fieldNumber: 601),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 2001),
+  ]
+  private static let _oneOfField_oneofInt32: Field<Self> = .singularInt32({ $0.oneofInt32 }, fieldNumber: 61, isUnset: { _ in false })
+  private static let _oneOfField_oneofInt64: Field<Self> = .singularInt64({ $0.oneofInt64 }, fieldNumber: 62, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 63, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint64: Field<Self> = .singularUInt64({ $0.oneofUint64 }, fieldNumber: 64, isUnset: { _ in false })
+  private static let _oneOfField_oneofSint32: Field<Self> = .singularSInt32({ $0.oneofSint32 }, fieldNumber: 65, isUnset: { _ in false })
+  private static let _oneOfField_oneofSint64: Field<Self> = .singularSInt64({ $0.oneofSint64 }, fieldNumber: 66, isUnset: { _ in false })
+  private static let _oneOfField_oneofFixed32: Field<Self> = .singularFixed32({ $0.oneofFixed32 }, fieldNumber: 67, isUnset: { _ in false })
+  private static let _oneOfField_oneofFixed64: Field<Self> = .singularFixed64({ $0.oneofFixed64 }, fieldNumber: 68, isUnset: { _ in false })
+  private static let _oneOfField_oneofSfixed32: Field<Self> = .singularSFixed32({ $0.oneofSfixed32 }, fieldNumber: 69, isUnset: { _ in false })
+  private static let _oneOfField_oneofSfixed64: Field<Self> = .singularSFixed64({ $0.oneofSfixed64 }, fieldNumber: 70, isUnset: { _ in false })
+  private static let _oneOfField_oneofFloat: Field<Self> = .singularFloat({ $0.oneofFloat }, fieldNumber: 71, isUnset: { _ in false })
+  private static let _oneOfField_oneofDouble: Field<Self> = .singularDouble({ $0.oneofDouble }, fieldNumber: 72, isUnset: { _ in false })
+  private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 73, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 74, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 75, isUnset: { _ in false })
+  private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 76, isUnset: { _ in false })
+  private static let _oneOfField_oneofGroup: Field<Self> = .singularGroup({ $0.oneofGroup }, fieldNumber: 77, isUnset: { _ in false })
+  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 79, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Fuzz_Message, rhs: SwiftProtoTesting_Fuzz_Message) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -5000,16 +4463,10 @@ extension SwiftProtoTesting_Fuzz_Message.SingularGroup: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 18)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupField }, fieldNumber: 18, isUnset: { $0._groupField == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Fuzz_Message.SingularGroup, rhs: SwiftProtoTesting_Fuzz_Message.SingularGroup) -> Bool {
     if lhs._groupField != rhs._groupField {return false}
@@ -5036,16 +4493,10 @@ extension SwiftProtoTesting_Fuzz_Message.RepeatedGroup: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 48)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupField }, fieldNumber: 48, isUnset: { $0._groupField == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Fuzz_Message.RepeatedGroup, rhs: SwiftProtoTesting_Fuzz_Message.RepeatedGroup) -> Bool {
     if lhs._groupField != rhs._groupField {return false}
@@ -5072,16 +4523,10 @@ extension SwiftProtoTesting_Fuzz_Message.OneofGroup: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 78)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupField }, fieldNumber: 78, isUnset: { $0._groupField == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Fuzz_Message.OneofGroup, rhs: SwiftProtoTesting_Fuzz_Message.OneofGroup) -> Bool {
     if lhs._groupField != rhs._groupField {return false}
@@ -5103,10 +4548,10 @@ extension SwiftProtoTesting_Fuzz_AMessageSetMessage: SwiftProtobuf.Message, Swif
     try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Fuzz_AMessageSetMessage.self)
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFieldsAsMessageSet({ $0._protobuf_extensionFieldValues }, start: 4, end: 2147483647),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessage, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -5133,16 +4578,10 @@ extension SwiftProtoTesting_Fuzz_SingularGroup_ext: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1018)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupField }, fieldNumber: 1018, isUnset: { $0._groupField == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Fuzz_SingularGroup_ext, rhs: SwiftProtoTesting_Fuzz_SingularGroup_ext) -> Bool {
     if lhs._groupField != rhs._groupField {return false}
@@ -5169,16 +4608,10 @@ extension SwiftProtoTesting_Fuzz_RepeatedGroup_ext: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._groupField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1048)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupField }, fieldNumber: 1048, isUnset: { $0._groupField == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Fuzz_RepeatedGroup_ext, rhs: SwiftProtoTesting_Fuzz_RepeatedGroup_ext) -> Bool {
     if lhs._groupField != rhs._groupField {return false}
diff --git a/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift b/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift
index 14aa898c5..90d1efc71 100644
--- a/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift
+++ b/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift
@@ -304,686 +304,744 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
   case enumValueOptions // = 275
   case equatable // = 276
   case error // = 277
-  case expressibleByArrayLiteral // = 278
-  case expressibleByDictionaryLiteral // = 279
-  case ext // = 280
-  case extDecoder // = 281
-  case extendedGraphemeClusterLiteral // = 282
-  case extendedGraphemeClusterLiteralType // = 283
-  case extendee // = 284
-  case extensibleMessage // = 285
-  case `extension` // = 286
-  case extensionField // = 287
-  case extensionFieldNumber // = 288
-  case extensionFieldValueSet // = 289
-  case extensionMap // = 290
-  case extensionRange // = 291
-  case extensionRangeOptions // = 292
-  case extensions // = 293
-  case extras // = 294
-  case f // = 295
-  case `false` // = 296
-  case features // = 297
-  case featureSet // = 298
-  case featureSetDefaults // = 299
-  case featureSetEditionDefault // = 300
-  case field // = 301
-  case fieldData // = 302
-  case fieldDescriptorProto // = 303
-  case fieldMask // = 304
-  case fieldName // = 305
-  case fieldNameCount // = 306
-  case fieldNum // = 307
-  case fieldNumber // = 308
-  case fieldNumberForProto // = 309
-  case fieldOptions // = 310
-  case fieldPresence // = 311
-  case fields // = 312
-  case fieldSize // = 313
-  case fieldTag // = 314
-  case fieldType // = 315
-  case file // = 316
-  case fileDescriptorProto // = 317
-  case fileDescriptorSet // = 318
-  case fileName // = 319
-  case fileOptions // = 320
-  case filter // = 321
-  case final // = 322
-  case first // = 323
-  case firstItem // = 324
-  case float // = 325
-  case floatLiteral // = 326
-  case floatLiteralType // = 327
-  case floatValue // = 328
-  case forMessageName // = 329
-  case formUnion // = 330
-  case forReadingFrom // = 331
-  case forTypeURL // = 332
-  case forwardParser // = 333
-  case forWritingInto // = 334
-  case from // = 335
-  case fromAscii2 // = 336
-  case fromAscii4 // = 337
-  case fromByteOffset // = 338
-  case fromHexDigit // = 339
-  case fullName // = 340
-  case `func` // = 341
-  case g // = 342
-  case generatedCodeInfo // = 343
-  case get // = 344
-  case getExtensionValue // = 345
-  case googleapis // = 346
-  case googleProtobufAny // = 347
-  case googleProtobufApi // = 348
-  case googleProtobufBoolValue // = 349
-  case googleProtobufBytesValue // = 350
-  case googleProtobufDescriptorProto // = 351
-  case googleProtobufDoubleValue // = 352
-  case googleProtobufDuration // = 353
-  case googleProtobufEdition // = 354
-  case googleProtobufEmpty // = 355
-  case googleProtobufEnum // = 356
-  case googleProtobufEnumDescriptorProto // = 357
-  case googleProtobufEnumOptions // = 358
-  case googleProtobufEnumValue // = 359
-  case googleProtobufEnumValueDescriptorProto // = 360
-  case googleProtobufEnumValueOptions // = 361
-  case googleProtobufExtensionRangeOptions // = 362
-  case googleProtobufFeatureSet // = 363
-  case googleProtobufFeatureSetDefaults // = 364
-  case googleProtobufField // = 365
-  case googleProtobufFieldDescriptorProto // = 366
-  case googleProtobufFieldMask // = 367
-  case googleProtobufFieldOptions // = 368
-  case googleProtobufFileDescriptorProto // = 369
-  case googleProtobufFileDescriptorSet // = 370
-  case googleProtobufFileOptions // = 371
-  case googleProtobufFloatValue // = 372
-  case googleProtobufGeneratedCodeInfo // = 373
-  case googleProtobufInt32Value // = 374
-  case googleProtobufInt64Value // = 375
-  case googleProtobufListValue // = 376
-  case googleProtobufMessageOptions // = 377
-  case googleProtobufMethod // = 378
-  case googleProtobufMethodDescriptorProto // = 379
-  case googleProtobufMethodOptions // = 380
-  case googleProtobufMixin // = 381
-  case googleProtobufNullValue // = 382
-  case googleProtobufOneofDescriptorProto // = 383
-  case googleProtobufOneofOptions // = 384
-  case googleProtobufOption // = 385
-  case googleProtobufServiceDescriptorProto // = 386
-  case googleProtobufServiceOptions // = 387
-  case googleProtobufSourceCodeInfo // = 388
-  case googleProtobufSourceContext // = 389
-  case googleProtobufStringValue // = 390
-  case googleProtobufStruct // = 391
-  case googleProtobufSyntax // = 392
-  case googleProtobufTimestamp // = 393
-  case googleProtobufType // = 394
-  case googleProtobufUint32Value // = 395
-  case googleProtobufUint64Value // = 396
-  case googleProtobufUninterpretedOption // = 397
-  case googleProtobufValue // = 398
-  case goPackage // = 399
-  case group // = 400
-  case groupFieldNumberStack // = 401
-  case groupSize // = 402
-  case hadOneofValue // = 403
-  case handleConflictingOneOf // = 404
-  case hasAggregateValue // = 405
-  case hasAllowAlias // = 406
-  case hasBegin // = 407
-  case hasCcEnableArenas // = 408
-  case hasCcGenericServices // = 409
-  case hasClientStreaming // = 410
-  case hasCsharpNamespace // = 411
-  case hasCtype // = 412
-  case hasDebugRedact // = 413
-  case hasDefaultValue // = 414
-  case hasDeprecated // = 415
-  case hasDeprecatedLegacyJsonFieldConflicts // = 416
-  case hasDoubleValue // = 417
-  case hasEdition // = 418
-  case hasEnd // = 419
-  case hasEnumType // = 420
-  case hasExtendee // = 421
-  case hasExtensionValue // = 422
-  case hasFeatures // = 423
-  case hasFieldPresence // = 424
-  case hasFullName // = 425
-  case hasGoPackage // = 426
-  case hash // = 427
-  case hashable // = 428
-  case hasher // = 429
-  case hashVisitor // = 430
-  case hasIdempotencyLevel // = 431
-  case hasIdentifierValue // = 432
-  case hasInputType // = 433
-  case hasIsExtension // = 434
-  case hasJavaGenerateEqualsAndHash // = 435
-  case hasJavaGenericServices // = 436
-  case hasJavaMultipleFiles // = 437
-  case hasJavaOuterClassname // = 438
-  case hasJavaPackage // = 439
-  case hasJavaStringCheckUtf8 // = 440
-  case hasJsonFormat // = 441
-  case hasJsonName // = 442
-  case hasJstype // = 443
-  case hasLabel // = 444
-  case hasLazy // = 445
-  case hasLeadingComments // = 446
-  case hasMapEntry // = 447
-  case hasMaximumEdition // = 448
-  case hasMessageEncoding // = 449
-  case hasMessageSetWireFormat // = 450
-  case hasMinimumEdition // = 451
-  case hasName // = 452
-  case hasNamePart // = 453
-  case hasNegativeIntValue // = 454
-  case hasNoStandardDescriptorAccessor // = 455
-  case hasNumber // = 456
-  case hasObjcClassPrefix // = 457
-  case hasOneofIndex // = 458
-  case hasOptimizeFor // = 459
-  case hasOptions // = 460
-  case hasOutputType // = 461
-  case hasPackage // = 462
-  case hasPacked // = 463
-  case hasPhpClassPrefix // = 464
-  case hasPhpGenericServices // = 465
-  case hasPhpMetadataNamespace // = 466
-  case hasPhpNamespace // = 467
-  case hasPositiveIntValue // = 468
-  case hasProto3Optional // = 469
-  case hasPyGenericServices // = 470
-  case hasRepeated // = 471
-  case hasRepeatedFieldEncoding // = 472
-  case hasReserved // = 473
-  case hasRetention // = 474
-  case hasRubyPackage // = 475
-  case hasSemantic // = 476
-  case hasServerStreaming // = 477
-  case hasSourceCodeInfo // = 478
-  case hasSourceContext // = 479
-  case hasSourceFile // = 480
-  case hasStart // = 481
-  case hasStringValue // = 482
-  case hasSwiftPrefix // = 483
-  case hasSyntax // = 484
-  case hasTrailingComments // = 485
-  case hasType // = 486
-  case hasTypeName // = 487
-  case hasUnverifiedLazy // = 488
-  case hasUtf8Validation // = 489
-  case hasValue // = 490
-  case hasVerification // = 491
-  case hasWeak // = 492
-  case hour // = 493
-  case i // = 494
-  case idempotencyLevel // = 495
-  case identifierValue // = 496
-  case `if` // = 497
-  case ignoreUnknownFields // = 498
-  case index // = 499
-  case init_ // = 500
-  case `inout` // = 501
-  case inputType // = 502
-  case insert // = 503
-  case int // = 504
-  case int32 // = 505
-  case int32Value // = 506
-  case int64 // = 507
-  case int64Value // = 508
-  case int8 // = 509
-  case integerLiteral // = 510
-  case integerLiteralType // = 511
-  case intern // = 512
-  case `internal` // = 513
-  case internalState // = 514
-  case into // = 515
-  case ints // = 516
-  case isA // = 517
-  case isEqual // = 518
-  case isEqualTo // = 519
-  case isExtension // = 520
-  case isInitialized // = 521
-  case isNegative // = 522
-  case itemTagsEncodedSize // = 523
-  case iterator // = 524
-  case javaGenerateEqualsAndHash // = 525
-  case javaGenericServices // = 526
-  case javaMultipleFiles // = 527
-  case javaOuterClassname // = 528
-  case javaPackage // = 529
-  case javaStringCheckUtf8 // = 530
-  case jsondecoder // = 531
-  case jsondecodingError // = 532
-  case jsondecodingOptions // = 533
-  case jsonEncoder // = 534
-  case jsonencodingError // = 535
-  case jsonencodingOptions // = 536
-  case jsonencodingVisitor // = 537
-  case jsonFormat // = 538
-  case jsonmapEncodingVisitor // = 539
-  case jsonName // = 540
-  case jsonPath // = 541
-  case jsonPaths // = 542
-  case jsonscanner // = 543
-  case jsonString // = 544
-  case jsonText // = 545
-  case jsonUtf8Bytes // = 546
-  case jsonUtf8Data // = 547
-  case jstype // = 548
-  case k // = 549
-  case kChunkSize // = 550
-  case key // = 551
-  case keyField // = 552
-  case keyFieldOpt // = 553
-  case keyType // = 554
-  case kind // = 555
-  case l // = 556
-  case label // = 557
-  case lazy // = 558
-  case leadingComments // = 559
-  case leadingDetachedComments // = 560
-  case length // = 561
-  case lessThan // = 562
-  case `let` // = 563
-  case lhs // = 564
-  case list // = 565
-  case listOfMessages // = 566
-  case listValue // = 567
-  case littleEndian // = 568
-  case littleEndianBytes // = 569
-  case load // = 570
-  case localHasher // = 571
-  case location // = 572
-  case m // = 573
-  case major // = 574
-  case makeAsyncIterator // = 575
-  case makeIterator // = 576
-  case mapEntry // = 577
-  case mapKeyType // = 578
-  case mapToMessages // = 579
-  case mapValueType // = 580
-  case mapVisitor // = 581
-  case maximumEdition // = 582
-  case mdayStart // = 583
-  case merge // = 584
-  case message // = 585
-  case messageDepthLimit // = 586
-  case messageEncoding // = 587
-  case messageExtension // = 588
-  case messageImplementationBase // = 589
-  case messageOptions // = 590
-  case messageSet // = 591
-  case messageSetWireFormat // = 592
-  case messageSize // = 593
-  case messageType // = 594
-  case method // = 595
-  case methodDescriptorProto // = 596
-  case methodOptions // = 597
-  case methods // = 598
-  case min // = 599
-  case minimumEdition // = 600
-  case minor // = 601
-  case mixin // = 602
-  case mixins // = 603
-  case modifier // = 604
-  case modify // = 605
-  case month // = 606
-  case msgExtension // = 607
-  case mutating // = 608
-  case n // = 609
-  case name // = 610
-  case nameDescription // = 611
-  case nameMap // = 612
-  case namePart // = 613
-  case names // = 614
-  case nanos // = 615
-  case negativeIntValue // = 616
-  case nestedType // = 617
-  case newL // = 618
-  case newList // = 619
-  case newValue // = 620
-  case next // = 621
-  case nextByte // = 622
-  case nextFieldNumber // = 623
-  case nextVarInt // = 624
-  case `nil` // = 625
-  case nilLiteral // = 626
-  case noStandardDescriptorAccessor // = 627
-  case nullValue // = 628
-  case number // = 629
-  case numberValue // = 630
-  case objcClassPrefix // = 631
-  case of // = 632
-  case oneofDecl // = 633
-  case oneofDescriptorProto // = 634
-  case oneofIndex // = 635
-  case oneofOptions // = 636
-  case oneofs // = 637
-  case oneOfKind // = 638
-  case optimizeFor // = 639
-  case optimizeMode // = 640
-  case option // = 641
-  case optionalEnumExtensionField // = 642
-  case optionalExtensionField // = 643
-  case optionalGroupExtensionField // = 644
-  case optionalMessageExtensionField // = 645
-  case optionRetention // = 646
-  case options // = 647
-  case optionTargetType // = 648
-  case other // = 649
-  case others // = 650
-  case out // = 651
-  case outputType // = 652
-  case p // = 653
-  case package // = 654
-  case packed // = 655
-  case packedEnumExtensionField // = 656
-  case packedExtensionField // = 657
-  case padding // = 658
-  case parent // = 659
-  case parse // = 660
-  case path // = 661
-  case paths // = 662
-  case payload // = 663
-  case payloadSize // = 664
-  case phpClassPrefix // = 665
-  case phpGenericServices // = 666
-  case phpMetadataNamespace // = 667
-  case phpNamespace // = 668
-  case pos // = 669
-  case positiveIntValue // = 670
-  case prefix // = 671
-  case preserveProtoFieldNames // = 672
-  case preTraverse // = 673
-  case printUnknownFields // = 674
-  case proto2 // = 675
-  case proto3DefaultValue // = 676
-  case proto3Optional // = 677
-  case protobufApiversionCheck // = 678
-  case protobufApiversion3 // = 679
-  case protobufBool // = 680
-  case protobufBytes // = 681
-  case protobufDouble // = 682
-  case protobufEnumMap // = 683
-  case protobufExtension // = 684
-  case protobufFixed32 // = 685
-  case protobufFixed64 // = 686
-  case protobufFloat // = 687
-  case protobufInt32 // = 688
-  case protobufInt64 // = 689
-  case protobufMap // = 690
-  case protobufMessageMap // = 691
-  case protobufSfixed32 // = 692
-  case protobufSfixed64 // = 693
-  case protobufSint32 // = 694
-  case protobufSint64 // = 695
-  case protobufString // = 696
-  case protobufUint32 // = 697
-  case protobufUint64 // = 698
-  case protobufExtensionFieldValues // = 699
-  case protobufFieldNumber // = 700
-  case protobufGeneratedIsEqualTo // = 701
-  case protobufNameMap // = 702
-  case protobufNewField // = 703
-  case protobufPackage // = 704
-  case `protocol` // = 705
-  case protoFieldName // = 706
-  case protoMessageName // = 707
-  case protoNameProviding // = 708
-  case protoPaths // = 709
-  case `public` // = 710
-  case publicDependency // = 711
-  case putBoolValue // = 712
-  case putBytesValue // = 713
-  case putDoubleValue // = 714
-  case putEnumValue // = 715
-  case putFixedUint32 // = 716
-  case putFixedUint64 // = 717
-  case putFloatValue // = 718
-  case putInt64 // = 719
-  case putStringValue // = 720
-  case putUint64 // = 721
-  case putUint64Hex // = 722
-  case putVarInt // = 723
-  case putZigZagVarInt // = 724
-  case pyGenericServices // = 725
-  case r // = 726
-  case rawChars // = 727
-  case rawRepresentable // = 728
-  case rawValue_ // = 729
-  case read4HexDigits // = 730
-  case readBytes // = 731
-  case register // = 732
-  case repeated // = 733
-  case repeatedEnumExtensionField // = 734
-  case repeatedExtensionField // = 735
-  case repeatedFieldEncoding // = 736
-  case repeatedGroupExtensionField // = 737
-  case repeatedMessageExtensionField // = 738
-  case repeating // = 739
-  case requestStreaming // = 740
-  case requestTypeURL // = 741
-  case requiredSize // = 742
-  case responseStreaming // = 743
-  case responseTypeURL // = 744
-  case result // = 745
-  case retention // = 746
-  case `rethrows` // = 747
-  case `return` // = 748
-  case returnType // = 749
-  case revision // = 750
-  case rhs // = 751
-  case root // = 752
-  case rubyPackage // = 753
-  case s // = 754
-  case sawBackslash // = 755
-  case sawSection4Characters // = 756
-  case sawSection5Characters // = 757
-  case scanner // = 758
-  case seconds // = 759
-  case self_ // = 760
-  case semantic // = 761
-  case sendable // = 762
-  case separator // = 763
-  case serialize // = 764
-  case serializedBytes // = 765
-  case serializedData // = 766
-  case serializedSize // = 767
-  case serverStreaming // = 768
-  case service // = 769
-  case serviceDescriptorProto // = 770
-  case serviceOptions // = 771
-  case set // = 772
-  case setExtensionValue // = 773
-  case shift // = 774
-  case simpleExtensionMap // = 775
-  case size // = 776
-  case sizer // = 777
-  case source // = 778
-  case sourceCodeInfo // = 779
-  case sourceContext // = 780
-  case sourceEncoding // = 781
-  case sourceFile // = 782
-  case span // = 783
-  case split // = 784
-  case start // = 785
-  case startArray // = 786
-  case startArrayObject // = 787
-  case startField // = 788
-  case startIndex // = 789
-  case startMessageField // = 790
-  case startObject // = 791
-  case startRegularField // = 792
-  case state // = 793
-  case `static` // = 794
-  case staticString // = 795
-  case storage // = 796
-  case string // = 797
-  case stringLiteral // = 798
-  case stringLiteralType // = 799
-  case stringResult // = 800
-  case stringValue // = 801
-  case `struct` // = 802
-  case structValue // = 803
-  case subDecoder // = 804
-  case `subscript` // = 805
-  case subVisitor // = 806
-  case swift // = 807
-  case swiftPrefix // = 808
-  case swiftProtobufContiguousBytes // = 809
-  case syntax // = 810
-  case t // = 811
-  case tag // = 812
-  case targets // = 813
-  case terminator // = 814
-  case testDecoder // = 815
-  case text // = 816
-  case textDecoder // = 817
-  case textFormatDecoder // = 818
-  case textFormatDecodingError // = 819
-  case textFormatDecodingOptions // = 820
-  case textFormatEncodingOptions // = 821
-  case textFormatEncodingVisitor // = 822
-  case textFormatString // = 823
-  case throwOrIgnore // = 824
-  case `throws` // = 825
-  case timeInterval // = 826
-  case timeIntervalSince1970 // = 827
-  case timeIntervalSinceReferenceDate // = 828
-  case timestamp // = 829
-  case total // = 830
-  case totalArrayDepth // = 831
-  case totalSize // = 832
-  case trailingComments // = 833
-  case traverse // = 834
-  case `true` // = 835
-  case `try` // = 836
-  case type // = 837
-  case `typealias` // = 838
-  case typeEnum // = 839
-  case typeName // = 840
-  case typePrefix // = 841
-  case typeStart // = 842
-  case typeUnknown // = 843
-  case typeURL // = 844
-  case uint32 // = 845
-  case uint32Value // = 846
-  case uint64 // = 847
-  case uint64Value // = 848
-  case uint8 // = 849
-  case unchecked // = 850
-  case unicodeScalarLiteral // = 851
-  case unicodeScalarLiteralType // = 852
-  case unicodeScalars // = 853
-  case unicodeScalarView // = 854
-  case uninterpretedOption // = 855
-  case union // = 856
-  case uniqueStorage // = 857
-  case unknown // = 858
-  case unknownFields // = 859
-  case unknownStorage // = 860
-  case unpackTo // = 861
-  case unsafeBufferPointer // = 862
-  case unsafeMutablePointer // = 863
-  case unsafeMutableRawBufferPointer // = 864
-  case unsafeRawBufferPointer // = 865
-  case unsafeRawPointer // = 866
-  case unverifiedLazy // = 867
-  case updatedOptions // = 868
-  case url // = 869
-  case useDeterministicOrdering // = 870
-  case utf8 // = 871
-  case utf8Ptr // = 872
-  case utf8ToDouble // = 873
-  case utf8Validation // = 874
-  case utf8View // = 875
-  case v // = 876
-  case value // = 877
-  case valueField // = 878
-  case values // = 879
-  case valueType // = 880
-  case `var` // = 881
-  case verification // = 882
-  case verificationState // = 883
-  case version // = 884
-  case versionString // = 885
-  case visitExtensionFields // = 886
-  case visitExtensionFieldsAsMessageSet // = 887
-  case visitMapField // = 888
-  case visitor // = 889
-  case visitPacked // = 890
-  case visitPackedBoolField // = 891
-  case visitPackedDoubleField // = 892
-  case visitPackedEnumField // = 893
-  case visitPackedFixed32Field // = 894
-  case visitPackedFixed64Field // = 895
-  case visitPackedFloatField // = 896
-  case visitPackedInt32Field // = 897
-  case visitPackedInt64Field // = 898
-  case visitPackedSfixed32Field // = 899
-  case visitPackedSfixed64Field // = 900
-  case visitPackedSint32Field // = 901
-  case visitPackedSint64Field // = 902
-  case visitPackedUint32Field // = 903
-  case visitPackedUint64Field // = 904
-  case visitRepeated // = 905
-  case visitRepeatedBoolField // = 906
-  case visitRepeatedBytesField // = 907
-  case visitRepeatedDoubleField // = 908
-  case visitRepeatedEnumField // = 909
-  case visitRepeatedFixed32Field // = 910
-  case visitRepeatedFixed64Field // = 911
-  case visitRepeatedFloatField // = 912
-  case visitRepeatedGroupField // = 913
-  case visitRepeatedInt32Field // = 914
-  case visitRepeatedInt64Field // = 915
-  case visitRepeatedMessageField // = 916
-  case visitRepeatedSfixed32Field // = 917
-  case visitRepeatedSfixed64Field // = 918
-  case visitRepeatedSint32Field // = 919
-  case visitRepeatedSint64Field // = 920
-  case visitRepeatedStringField // = 921
-  case visitRepeatedUint32Field // = 922
-  case visitRepeatedUint64Field // = 923
-  case visitSingular // = 924
-  case visitSingularBoolField // = 925
-  case visitSingularBytesField // = 926
-  case visitSingularDoubleField // = 927
-  case visitSingularEnumField // = 928
-  case visitSingularFixed32Field // = 929
-  case visitSingularFixed64Field // = 930
-  case visitSingularFloatField // = 931
-  case visitSingularGroupField // = 932
-  case visitSingularInt32Field // = 933
-  case visitSingularInt64Field // = 934
-  case visitSingularMessageField // = 935
-  case visitSingularSfixed32Field // = 936
-  case visitSingularSfixed64Field // = 937
-  case visitSingularSint32Field // = 938
-  case visitSingularSint64Field // = 939
-  case visitSingularStringField // = 940
-  case visitSingularUint32Field // = 941
-  case visitSingularUint64Field // = 942
-  case visitUnknown // = 943
-  case wasDecoded // = 944
-  case weak // = 945
-  case weakDependency // = 946
-  case `where` // = 947
-  case wireFormat // = 948
-  case with // = 949
-  case withUnsafeBytes // = 950
-  case withUnsafeMutableBytes // = 951
-  case work // = 952
-  case wrapped // = 953
-  case wrappedType // = 954
-  case wrappedValue // = 955
-  case written // = 956
-  case yday // = 957
+  case escaping // = 278
+  case expressibleByArrayLiteral // = 279
+  case expressibleByDictionaryLiteral // = 280
+  case ext // = 281
+  case extDecoder // = 282
+  case extendedGraphemeClusterLiteral // = 283
+  case extendedGraphemeClusterLiteralType // = 284
+  case extendee // = 285
+  case extensibleMessage // = 286
+  case `extension` // = 287
+  case extensionField // = 288
+  case extensionFieldNumber // = 289
+  case extensionFields // = 290
+  case extensionFieldsAsMessageSet // = 291
+  case extensionFieldValueSet // = 292
+  case extensionMap // = 293
+  case extensionRange // = 294
+  case extensionRangeOptions // = 295
+  case extensions // = 296
+  case extras // = 297
+  case f // = 298
+  case `false` // = 299
+  case features // = 300
+  case featureSet // = 301
+  case featureSetDefaults // = 302
+  case featureSetEditionDefault // = 303
+  case field // = 304
+  case fieldData // = 305
+  case fieldDescriptorProto // = 306
+  case fieldMask // = 307
+  case fieldName // = 308
+  case fieldNameCount // = 309
+  case fieldNum // = 310
+  case fieldNumber // = 311
+  case fieldNumberForProto // = 312
+  case fieldOptions // = 313
+  case fieldPresence // = 314
+  case fields // = 315
+  case fieldSize // = 316
+  case fieldTag // = 317
+  case fieldType // = 318
+  case file // = 319
+  case fileDescriptorProto // = 320
+  case fileDescriptorSet // = 321
+  case fileName // = 322
+  case fileOptions // = 323
+  case filter // = 324
+  case final // = 325
+  case first // = 326
+  case firstItem // = 327
+  case float // = 328
+  case floatLiteral // = 329
+  case floatLiteralType // = 330
+  case floatValue // = 331
+  case forMessageName // = 332
+  case formUnion // = 333
+  case forReadingFrom // = 334
+  case forTypeURL // = 335
+  case forwardParser // = 336
+  case forWritingInto // = 337
+  case from // = 338
+  case fromAscii2 // = 339
+  case fromAscii4 // = 340
+  case fromByteOffset // = 341
+  case fromHexDigit // = 342
+  case fullName // = 343
+  case `func` // = 344
+  case g // = 345
+  case generatedCodeInfo // = 346
+  case get // = 347
+  case getExtensionValue // = 348
+  case getValue // = 349
+  case googleapis // = 350
+  case googleProtobufAny // = 351
+  case googleProtobufApi // = 352
+  case googleProtobufBoolValue // = 353
+  case googleProtobufBytesValue // = 354
+  case googleProtobufDescriptorProto // = 355
+  case googleProtobufDoubleValue // = 356
+  case googleProtobufDuration // = 357
+  case googleProtobufEdition // = 358
+  case googleProtobufEmpty // = 359
+  case googleProtobufEnum // = 360
+  case googleProtobufEnumDescriptorProto // = 361
+  case googleProtobufEnumOptions // = 362
+  case googleProtobufEnumValue // = 363
+  case googleProtobufEnumValueDescriptorProto // = 364
+  case googleProtobufEnumValueOptions // = 365
+  case googleProtobufExtensionRangeOptions // = 366
+  case googleProtobufFeatureSet // = 367
+  case googleProtobufFeatureSetDefaults // = 368
+  case googleProtobufField // = 369
+  case googleProtobufFieldDescriptorProto // = 370
+  case googleProtobufFieldMask // = 371
+  case googleProtobufFieldOptions // = 372
+  case googleProtobufFileDescriptorProto // = 373
+  case googleProtobufFileDescriptorSet // = 374
+  case googleProtobufFileOptions // = 375
+  case googleProtobufFloatValue // = 376
+  case googleProtobufGeneratedCodeInfo // = 377
+  case googleProtobufInt32Value // = 378
+  case googleProtobufInt64Value // = 379
+  case googleProtobufListValue // = 380
+  case googleProtobufMessageOptions // = 381
+  case googleProtobufMethod // = 382
+  case googleProtobufMethodDescriptorProto // = 383
+  case googleProtobufMethodOptions // = 384
+  case googleProtobufMixin // = 385
+  case googleProtobufNullValue // = 386
+  case googleProtobufOneofDescriptorProto // = 387
+  case googleProtobufOneofOptions // = 388
+  case googleProtobufOption // = 389
+  case googleProtobufServiceDescriptorProto // = 390
+  case googleProtobufServiceOptions // = 391
+  case googleProtobufSourceCodeInfo // = 392
+  case googleProtobufSourceContext // = 393
+  case googleProtobufStringValue // = 394
+  case googleProtobufStruct // = 395
+  case googleProtobufSyntax // = 396
+  case googleProtobufTimestamp // = 397
+  case googleProtobufType // = 398
+  case googleProtobufUint32Value // = 399
+  case googleProtobufUint64Value // = 400
+  case googleProtobufUninterpretedOption // = 401
+  case googleProtobufValue // = 402
+  case goPackage // = 403
+  case group // = 404
+  case groupFieldNumberStack // = 405
+  case groupSize // = 406
+  case hadOneofValue // = 407
+  case handleConflictingOneOf // = 408
+  case hasAggregateValue // = 409
+  case hasAllowAlias // = 410
+  case hasBegin // = 411
+  case hasCcEnableArenas // = 412
+  case hasCcGenericServices // = 413
+  case hasClientStreaming // = 414
+  case hasCsharpNamespace // = 415
+  case hasCtype // = 416
+  case hasDebugRedact // = 417
+  case hasDefaultValue // = 418
+  case hasDeprecated // = 419
+  case hasDeprecatedLegacyJsonFieldConflicts // = 420
+  case hasDoubleValue // = 421
+  case hasEdition // = 422
+  case hasEnd // = 423
+  case hasEnumType // = 424
+  case hasExtendee // = 425
+  case hasExtensionValue // = 426
+  case hasFeatures // = 427
+  case hasFieldPresence // = 428
+  case hasFullName // = 429
+  case hasGoPackage // = 430
+  case hash // = 431
+  case hashable // = 432
+  case hasher // = 433
+  case hashVisitor // = 434
+  case hasIdempotencyLevel // = 435
+  case hasIdentifierValue // = 436
+  case hasInputType // = 437
+  case hasIsExtension // = 438
+  case hasJavaGenerateEqualsAndHash // = 439
+  case hasJavaGenericServices // = 440
+  case hasJavaMultipleFiles // = 441
+  case hasJavaOuterClassname // = 442
+  case hasJavaPackage // = 443
+  case hasJavaStringCheckUtf8 // = 444
+  case hasJsonFormat // = 445
+  case hasJsonName // = 446
+  case hasJstype // = 447
+  case hasLabel // = 448
+  case hasLazy // = 449
+  case hasLeadingComments // = 450
+  case hasMapEntry // = 451
+  case hasMaximumEdition // = 452
+  case hasMessageEncoding // = 453
+  case hasMessageSetWireFormat // = 454
+  case hasMinimumEdition // = 455
+  case hasName // = 456
+  case hasNamePart // = 457
+  case hasNegativeIntValue // = 458
+  case hasNoStandardDescriptorAccessor // = 459
+  case hasNumber // = 460
+  case hasObjcClassPrefix // = 461
+  case hasOneofIndex // = 462
+  case hasOptimizeFor // = 463
+  case hasOptions // = 464
+  case hasOutputType // = 465
+  case hasPackage // = 466
+  case hasPacked // = 467
+  case hasPhpClassPrefix // = 468
+  case hasPhpGenericServices // = 469
+  case hasPhpMetadataNamespace // = 470
+  case hasPhpNamespace // = 471
+  case hasPositiveIntValue // = 472
+  case hasProto3Optional // = 473
+  case hasPyGenericServices // = 474
+  case hasRepeated // = 475
+  case hasRepeatedFieldEncoding // = 476
+  case hasReserved // = 477
+  case hasRetention // = 478
+  case hasRubyPackage // = 479
+  case hasSemantic // = 480
+  case hasServerStreaming // = 481
+  case hasSourceCodeInfo // = 482
+  case hasSourceContext // = 483
+  case hasSourceFile // = 484
+  case hasStart // = 485
+  case hasStringValue // = 486
+  case hasSwiftPrefix // = 487
+  case hasSyntax // = 488
+  case hasTrailingComments // = 489
+  case hasType // = 490
+  case hasTypeName // = 491
+  case hasUnverifiedLazy // = 492
+  case hasUtf8Validation // = 493
+  case hasValue // = 494
+  case hasVerification // = 495
+  case hasWeak // = 496
+  case hour // = 497
+  case i // = 498
+  case idempotencyLevel // = 499
+  case identifierValue // = 500
+  case `if` // = 501
+  case ignoreUnknownFields // = 502
+  case index // = 503
+  case init_ // = 504
+  case `inout` // = 505
+  case inputType // = 506
+  case insert // = 507
+  case int // = 508
+  case int32 // = 509
+  case int32Value // = 510
+  case int64 // = 511
+  case int64Value // = 512
+  case int8 // = 513
+  case integerLiteral // = 514
+  case integerLiteralType // = 515
+  case intern // = 516
+  case `internal` // = 517
+  case internalState // = 518
+  case into // = 519
+  case ints // = 520
+  case isA // = 521
+  case isEqual // = 522
+  case isEqualTo // = 523
+  case isExtension // = 524
+  case isInitialized // = 525
+  case isNegative // = 526
+  case isUnset // = 527
+  case itemTagsEncodedSize // = 528
+  case iterator // = 529
+  case javaGenerateEqualsAndHash // = 530
+  case javaGenericServices // = 531
+  case javaMultipleFiles // = 532
+  case javaOuterClassname // = 533
+  case javaPackage // = 534
+  case javaStringCheckUtf8 // = 535
+  case jsondecoder // = 536
+  case jsondecodingError // = 537
+  case jsondecodingOptions // = 538
+  case jsonEncoder // = 539
+  case jsonencodingError // = 540
+  case jsonencodingOptions // = 541
+  case jsonencodingVisitor // = 542
+  case jsonFormat // = 543
+  case jsonmapEncodingVisitor // = 544
+  case jsonName // = 545
+  case jsonPath // = 546
+  case jsonPaths // = 547
+  case jsonscanner // = 548
+  case jsonString // = 549
+  case jsonText // = 550
+  case jsonUtf8Bytes // = 551
+  case jsonUtf8Data // = 552
+  case jstype // = 553
+  case k // = 554
+  case kChunkSize // = 555
+  case key // = 556
+  case keyField // = 557
+  case keyFieldOpt // = 558
+  case keyType // = 559
+  case kind // = 560
+  case l // = 561
+  case label // = 562
+  case lazy // = 563
+  case leadingComments // = 564
+  case leadingDetachedComments // = 565
+  case length // = 566
+  case lessThan // = 567
+  case `let` // = 568
+  case lhs // = 569
+  case list // = 570
+  case listOfMessages // = 571
+  case listValue // = 572
+  case littleEndian // = 573
+  case littleEndianBytes // = 574
+  case load // = 575
+  case localHasher // = 576
+  case location // = 577
+  case m // = 578
+  case major // = 579
+  case makeAsyncIterator // = 580
+  case makeIterator // = 581
+  case map // = 582
+  case mapEntry // = 583
+  case mapKeyType // = 584
+  case mapToMessages // = 585
+  case mapValueType // = 586
+  case mapVisitor // = 587
+  case maximumEdition // = 588
+  case mdayStart // = 589
+  case merge // = 590
+  case message // = 591
+  case messageDepthLimit // = 592
+  case messageEncoding // = 593
+  case messageExtension // = 594
+  case messageImplementationBase // = 595
+  case messageOptions // = 596
+  case messageSet // = 597
+  case messageSetWireFormat // = 598
+  case messageSize // = 599
+  case messageType // = 600
+  case method // = 601
+  case methodDescriptorProto // = 602
+  case methodOptions // = 603
+  case methods // = 604
+  case min // = 605
+  case minimumEdition // = 606
+  case minor // = 607
+  case mixin // = 608
+  case mixins // = 609
+  case modifier // = 610
+  case modify // = 611
+  case month // = 612
+  case msgExtension // = 613
+  case mutating // = 614
+  case n // = 615
+  case name // = 616
+  case nameDescription // = 617
+  case nameMap // = 618
+  case namePart // = 619
+  case names // = 620
+  case nanos // = 621
+  case negativeIntValue // = 622
+  case nestedType // = 623
+  case newL // = 624
+  case newList // = 625
+  case newValue // = 626
+  case next // = 627
+  case nextByte // = 628
+  case nextFieldNumber // = 629
+  case nextVarInt // = 630
+  case `nil` // = 631
+  case nilLiteral // = 632
+  case noStandardDescriptorAccessor // = 633
+  case nullValue // = 634
+  case number // = 635
+  case numberValue // = 636
+  case objcClassPrefix // = 637
+  case of // = 638
+  case oneOf // = 639
+  case oneofDecl // = 640
+  case oneofDescriptorProto // = 641
+  case oneofIndex // = 642
+  case oneofOptions // = 643
+  case oneofs // = 644
+  case oneOfKind // = 645
+  case optimizeFor // = 646
+  case optimizeMode // = 647
+  case option // = 648
+  case optionalEnumExtensionField // = 649
+  case optionalExtensionField // = 650
+  case optionalGroupExtensionField // = 651
+  case optionalMessageExtensionField // = 652
+  case optionRetention // = 653
+  case options // = 654
+  case optionTargetType // = 655
+  case other // = 656
+  case others // = 657
+  case out // = 658
+  case outputType // = 659
+  case p // = 660
+  case package // = 661
+  case packed // = 662
+  case packedBool // = 663
+  case packedDouble // = 664
+  case packedEnum // = 665
+  case packedEnumExtensionField // = 666
+  case packedExtensionField // = 667
+  case packedFixed32 // = 668
+  case packedFixed64 // = 669
+  case packedFloat // = 670
+  case packedInt32 // = 671
+  case packedInt64 // = 672
+  case packedSfixed32 // = 673
+  case packedSfixed64 // = 674
+  case packedSint32 // = 675
+  case packedSint64 // = 676
+  case packedUint32 // = 677
+  case packedUint64 // = 678
+  case padding // = 679
+  case parent // = 680
+  case parse // = 681
+  case path // = 682
+  case paths // = 683
+  case payload // = 684
+  case payloadSize // = 685
+  case phpClassPrefix // = 686
+  case phpGenericServices // = 687
+  case phpMetadataNamespace // = 688
+  case phpNamespace // = 689
+  case pos // = 690
+  case positiveIntValue // = 691
+  case prefix // = 692
+  case preserveProtoFieldNames // = 693
+  case preTraverse // = 694
+  case printUnknownFields // = 695
+  case proto2 // = 696
+  case proto3DefaultValue // = 697
+  case proto3Optional // = 698
+  case protobufApiversionCheck // = 699
+  case protobufApiversion3 // = 700
+  case protobufBool // = 701
+  case protobufBytes // = 702
+  case protobufDouble // = 703
+  case protobufEnumMap // = 704
+  case protobufExtension // = 705
+  case protobufFixed32 // = 706
+  case protobufFixed64 // = 707
+  case protobufFloat // = 708
+  case protobufInt32 // = 709
+  case protobufInt64 // = 710
+  case protobufMap // = 711
+  case protobufMessageMap // = 712
+  case protobufSfixed32 // = 713
+  case protobufSfixed64 // = 714
+  case protobufSint32 // = 715
+  case protobufSint64 // = 716
+  case protobufString // = 717
+  case protobufUint32 // = 718
+  case protobufUint64 // = 719
+  case protobufExtensionFieldValues // = 720
+  case protobufFieldNumber // = 721
+  case protobufGeneratedIsEqualTo // = 722
+  case protobufNameMap // = 723
+  case protobufNewField // = 724
+  case protobufPackage // = 725
+  case `protocol` // = 726
+  case protoFieldName // = 727
+  case protoMessageName // = 728
+  case protoNameProviding // = 729
+  case protoPaths // = 730
+  case `public` // = 731
+  case publicDependency // = 732
+  case putBoolValue // = 733
+  case putBytesValue // = 734
+  case putDoubleValue // = 735
+  case putEnumValue // = 736
+  case putFixedUint32 // = 737
+  case putFixedUint64 // = 738
+  case putFloatValue // = 739
+  case putInt64 // = 740
+  case putStringValue // = 741
+  case putUint64 // = 742
+  case putUint64Hex // = 743
+  case putVarInt // = 744
+  case putZigZagVarInt // = 745
+  case pyGenericServices // = 746
+  case r // = 747
+  case rawChars // = 748
+  case rawRepresentable // = 749
+  case rawValue_ // = 750
+  case read4HexDigits // = 751
+  case readBytes // = 752
+  case register // = 753
+  case repeated // = 754
+  case repeatedBool // = 755
+  case repeatedBytes // = 756
+  case repeatedDouble // = 757
+  case repeatedEnum // = 758
+  case repeatedEnumExtensionField // = 759
+  case repeatedExtensionField // = 760
+  case repeatedFieldEncoding // = 761
+  case repeatedFixed32 // = 762
+  case repeatedFixed64 // = 763
+  case repeatedFloat // = 764
+  case repeatedGroup // = 765
+  case repeatedGroupExtensionField // = 766
+  case repeatedInt32 // = 767
+  case repeatedInt64 // = 768
+  case repeatedMessage // = 769
+  case repeatedMessageExtensionField // = 770
+  case repeatedSfixed32 // = 771
+  case repeatedSfixed64 // = 772
+  case repeatedSint32 // = 773
+  case repeatedSint64 // = 774
+  case repeatedString // = 775
+  case repeatedUint32 // = 776
+  case repeatedUint64 // = 777
+  case repeating // = 778
+  case requestStreaming // = 779
+  case requestTypeURL // = 780
+  case requiredSize // = 781
+  case responseStreaming // = 782
+  case responseTypeURL // = 783
+  case result // = 784
+  case retention // = 785
+  case `rethrows` // = 786
+  case `return` // = 787
+  case returnType // = 788
+  case revision // = 789
+  case rhs // = 790
+  case root // = 791
+  case rubyPackage // = 792
+  case s // = 793
+  case sawBackslash // = 794
+  case sawSection4Characters // = 795
+  case sawSection5Characters // = 796
+  case scanner // = 797
+  case seconds // = 798
+  case self_ // = 799
+  case semantic // = 800
+  case sendable // = 801
+  case separator // = 802
+  case serialize // = 803
+  case serializedBytes // = 804
+  case serializedData // = 805
+  case serializedSize // = 806
+  case serverStreaming // = 807
+  case service // = 808
+  case serviceDescriptorProto // = 809
+  case serviceOptions // = 810
+  case set // = 811
+  case setExtensionValue // = 812
+  case shift // = 813
+  case simpleExtensionMap // = 814
+  case singularBool // = 815
+  case singularBytes // = 816
+  case singularDouble // = 817
+  case singularEnum // = 818
+  case singularFixed32 // = 819
+  case singularFixed64 // = 820
+  case singularFloat // = 821
+  case singularGroup // = 822
+  case singularInt32 // = 823
+  case singularInt64 // = 824
+  case singularMessage // = 825
+  case singularSfixed32 // = 826
+  case singularSfixed64 // = 827
+  case singularSint32 // = 828
+  case singularSint64 // = 829
+  case singularString // = 830
+  case singularUint32 // = 831
+  case singularUint64 // = 832
+  case size // = 833
+  case sizer // = 834
+  case source // = 835
+  case sourceCodeInfo // = 836
+  case sourceContext // = 837
+  case sourceEncoding // = 838
+  case sourceFile // = 839
+  case span // = 840
+  case split // = 841
+  case start // = 842
+  case startArray // = 843
+  case startArrayObject // = 844
+  case startField // = 845
+  case startIndex // = 846
+  case startMessageField // = 847
+  case startObject // = 848
+  case startRegularField // = 849
+  case state // = 850
+  case `static` // = 851
+  case staticString // = 852
+  case storage // = 853
+  case string // = 854
+  case stringLiteral // = 855
+  case stringLiteralType // = 856
+  case stringResult // = 857
+  case stringValue // = 858
+  case `struct` // = 859
+  case structValue // = 860
+  case subDecoder // = 861
+  case `subscript` // = 862
+  case subVisitor // = 863
+  case swift // = 864
+  case swiftPrefix // = 865
+  case swiftProtobufContiguousBytes // = 866
+  case syntax // = 867
+  case t // = 868
+  case tag // = 869
+  case targets // = 870
+  case terminator // = 871
+  case testDecoder // = 872
+  case text // = 873
+  case textDecoder // = 874
+  case textFormatDecoder // = 875
+  case textFormatDecodingError // = 876
+  case textFormatDecodingOptions // = 877
+  case textFormatEncodingOptions // = 878
+  case textFormatEncodingVisitor // = 879
+  case textFormatString // = 880
+  case throwOrIgnore // = 881
+  case `throws` // = 882
+  case timeInterval // = 883
+  case timeIntervalSince1970 // = 884
+  case timeIntervalSinceReferenceDate // = 885
+  case timestamp // = 886
+  case toConcrete // = 887
+  case total // = 888
+  case totalArrayDepth // = 889
+  case totalSize // = 890
+  case trailingComments // = 891
+  case traverse // = 892
+  case `true` // = 893
+  case `try` // = 894
+  case type // = 895
+  case `typealias` // = 896
+  case typeEnum // = 897
+  case typeName // = 898
+  case typePrefix // = 899
+  case typeStart // = 900
+  case typeUnknown // = 901
+  case typeURL // = 902
+  case uint32 // = 903
+  case uint32Value // = 904
+  case uint64 // = 905
+  case uint64Value // = 906
+  case uint8 // = 907
+  case unchecked // = 908
+  case unicodeScalarLiteral // = 909
+  case unicodeScalarLiteralType // = 910
+  case unicodeScalars // = 911
+  case unicodeScalarView // = 912
+  case uninterpretedOption // = 913
+  case union // = 914
+  case uniqueStorage // = 915
+  case unknown // = 916
+  case unknownFields // = 917
+  case unknownStorage // = 918
+  case unpackTo // = 919
+  case unsafeBufferPointer // = 920
+  case unsafeMutablePointer // = 921
+  case unsafeMutableRawBufferPointer // = 922
+  case unsafeRawBufferPointer // = 923
+  case unsafeRawPointer // = 924
+  case unverifiedLazy // = 925
+  case updatedOptions // = 926
+  case url // = 927
+  case useDeterministicOrdering // = 928
+  case utf8 // = 929
+  case utf8Ptr // = 930
+  case utf8ToDouble // = 931
+  case utf8Validation // = 932
+  case utf8View // = 933
+  case v // = 934
+  case value // = 935
+  case valueField // = 936
+  case values // = 937
+  case valueType // = 938
+  case `var` // = 939
+  case verification // = 940
+  case verificationState // = 941
+  case version // = 942
+  case versionString // = 943
+  case visitExtensionFields // = 944
+  case visitExtensionFieldsAsMessageSet // = 945
+  case visitMapField // = 946
+  case visitor // = 947
+  case visitPacked // = 948
+  case visitPackedBoolField // = 949
+  case visitPackedDoubleField // = 950
+  case visitPackedEnumField // = 951
+  case visitPackedFixed32Field // = 952
+  case visitPackedFixed64Field // = 953
+  case visitPackedFloatField // = 954
+  case visitPackedInt32Field // = 955
+  case visitPackedInt64Field // = 956
+  case visitPackedSfixed32Field // = 957
+  case visitPackedSfixed64Field // = 958
+  case visitPackedSint32Field // = 959
+  case visitPackedSint64Field // = 960
+  case visitPackedUint32Field // = 961
+  case visitPackedUint64Field // = 962
+  case visitRepeated // = 963
+  case visitRepeatedBoolField // = 964
+  case visitRepeatedBytesField // = 965
+  case visitRepeatedDoubleField // = 966
+  case visitRepeatedEnumField // = 967
+  case visitRepeatedFixed32Field // = 968
+  case visitRepeatedFixed64Field // = 969
+  case visitRepeatedFloatField // = 970
+  case visitRepeatedGroupField // = 971
+  case visitRepeatedInt32Field // = 972
+  case visitRepeatedInt64Field // = 973
+  case visitRepeatedMessageField // = 974
+  case visitRepeatedSfixed32Field // = 975
+  case visitRepeatedSfixed64Field // = 976
+  case visitRepeatedSint32Field // = 977
+  case visitRepeatedSint64Field // = 978
+  case visitRepeatedStringField // = 979
+  case visitRepeatedUint32Field // = 980
+  case visitRepeatedUint64Field // = 981
+  case visitSingular // = 982
+  case visitSingularBoolField // = 983
+  case visitSingularBytesField // = 984
+  case visitSingularDoubleField // = 985
+  case visitSingularEnumField // = 986
+  case visitSingularFixed32Field // = 987
+  case visitSingularFixed64Field // = 988
+  case visitSingularFloatField // = 989
+  case visitSingularGroupField // = 990
+  case visitSingularInt32Field // = 991
+  case visitSingularInt64Field // = 992
+  case visitSingularMessageField // = 993
+  case visitSingularSfixed32Field // = 994
+  case visitSingularSfixed64Field // = 995
+  case visitSingularSint32Field // = 996
+  case visitSingularSint64Field // = 997
+  case visitSingularStringField // = 998
+  case visitSingularUint32Field // = 999
+  case visitSingularUint64Field // = 1000
+  case visitUnknown // = 1001
+  case wasDecoded // = 1002
+  case weak // = 1003
+  case weakDependency // = 1004
+  case `where` // = 1005
+  case wireFormat // = 1006
+  case with // = 1007
+  case withUnsafeBytes // = 1008
+  case withUnsafeMutableBytes // = 1009
+  case work // = 1010
+  case wrapped // = 1011
+  case wrappedType // = 1012
+  case wrappedValue // = 1013
+  case written // = 1014
+  case yday // = 1015
   case UNRECOGNIZED(Int)
 
   init() {
@@ -1270,686 +1328,744 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     case 275: self = .enumValueOptions
     case 276: self = .equatable
     case 277: self = .error
-    case 278: self = .expressibleByArrayLiteral
-    case 279: self = .expressibleByDictionaryLiteral
-    case 280: self = .ext
-    case 281: self = .extDecoder
-    case 282: self = .extendedGraphemeClusterLiteral
-    case 283: self = .extendedGraphemeClusterLiteralType
-    case 284: self = .extendee
-    case 285: self = .extensibleMessage
-    case 286: self = .extension
-    case 287: self = .extensionField
-    case 288: self = .extensionFieldNumber
-    case 289: self = .extensionFieldValueSet
-    case 290: self = .extensionMap
-    case 291: self = .extensionRange
-    case 292: self = .extensionRangeOptions
-    case 293: self = .extensions
-    case 294: self = .extras
-    case 295: self = .f
-    case 296: self = .false
-    case 297: self = .features
-    case 298: self = .featureSet
-    case 299: self = .featureSetDefaults
-    case 300: self = .featureSetEditionDefault
-    case 301: self = .field
-    case 302: self = .fieldData
-    case 303: self = .fieldDescriptorProto
-    case 304: self = .fieldMask
-    case 305: self = .fieldName
-    case 306: self = .fieldNameCount
-    case 307: self = .fieldNum
-    case 308: self = .fieldNumber
-    case 309: self = .fieldNumberForProto
-    case 310: self = .fieldOptions
-    case 311: self = .fieldPresence
-    case 312: self = .fields
-    case 313: self = .fieldSize
-    case 314: self = .fieldTag
-    case 315: self = .fieldType
-    case 316: self = .file
-    case 317: self = .fileDescriptorProto
-    case 318: self = .fileDescriptorSet
-    case 319: self = .fileName
-    case 320: self = .fileOptions
-    case 321: self = .filter
-    case 322: self = .final
-    case 323: self = .first
-    case 324: self = .firstItem
-    case 325: self = .float
-    case 326: self = .floatLiteral
-    case 327: self = .floatLiteralType
-    case 328: self = .floatValue
-    case 329: self = .forMessageName
-    case 330: self = .formUnion
-    case 331: self = .forReadingFrom
-    case 332: self = .forTypeURL
-    case 333: self = .forwardParser
-    case 334: self = .forWritingInto
-    case 335: self = .from
-    case 336: self = .fromAscii2
-    case 337: self = .fromAscii4
-    case 338: self = .fromByteOffset
-    case 339: self = .fromHexDigit
-    case 340: self = .fullName
-    case 341: self = .func
-    case 342: self = .g
-    case 343: self = .generatedCodeInfo
-    case 344: self = .get
-    case 345: self = .getExtensionValue
-    case 346: self = .googleapis
-    case 347: self = .googleProtobufAny
-    case 348: self = .googleProtobufApi
-    case 349: self = .googleProtobufBoolValue
-    case 350: self = .googleProtobufBytesValue
-    case 351: self = .googleProtobufDescriptorProto
-    case 352: self = .googleProtobufDoubleValue
-    case 353: self = .googleProtobufDuration
-    case 354: self = .googleProtobufEdition
-    case 355: self = .googleProtobufEmpty
-    case 356: self = .googleProtobufEnum
-    case 357: self = .googleProtobufEnumDescriptorProto
-    case 358: self = .googleProtobufEnumOptions
-    case 359: self = .googleProtobufEnumValue
-    case 360: self = .googleProtobufEnumValueDescriptorProto
-    case 361: self = .googleProtobufEnumValueOptions
-    case 362: self = .googleProtobufExtensionRangeOptions
-    case 363: self = .googleProtobufFeatureSet
-    case 364: self = .googleProtobufFeatureSetDefaults
-    case 365: self = .googleProtobufField
-    case 366: self = .googleProtobufFieldDescriptorProto
-    case 367: self = .googleProtobufFieldMask
-    case 368: self = .googleProtobufFieldOptions
-    case 369: self = .googleProtobufFileDescriptorProto
-    case 370: self = .googleProtobufFileDescriptorSet
-    case 371: self = .googleProtobufFileOptions
-    case 372: self = .googleProtobufFloatValue
-    case 373: self = .googleProtobufGeneratedCodeInfo
-    case 374: self = .googleProtobufInt32Value
-    case 375: self = .googleProtobufInt64Value
-    case 376: self = .googleProtobufListValue
-    case 377: self = .googleProtobufMessageOptions
-    case 378: self = .googleProtobufMethod
-    case 379: self = .googleProtobufMethodDescriptorProto
-    case 380: self = .googleProtobufMethodOptions
-    case 381: self = .googleProtobufMixin
-    case 382: self = .googleProtobufNullValue
-    case 383: self = .googleProtobufOneofDescriptorProto
-    case 384: self = .googleProtobufOneofOptions
-    case 385: self = .googleProtobufOption
-    case 386: self = .googleProtobufServiceDescriptorProto
-    case 387: self = .googleProtobufServiceOptions
-    case 388: self = .googleProtobufSourceCodeInfo
-    case 389: self = .googleProtobufSourceContext
-    case 390: self = .googleProtobufStringValue
-    case 391: self = .googleProtobufStruct
-    case 392: self = .googleProtobufSyntax
-    case 393: self = .googleProtobufTimestamp
-    case 394: self = .googleProtobufType
-    case 395: self = .googleProtobufUint32Value
-    case 396: self = .googleProtobufUint64Value
-    case 397: self = .googleProtobufUninterpretedOption
-    case 398: self = .googleProtobufValue
-    case 399: self = .goPackage
-    case 400: self = .group
-    case 401: self = .groupFieldNumberStack
-    case 402: self = .groupSize
-    case 403: self = .hadOneofValue
-    case 404: self = .handleConflictingOneOf
-    case 405: self = .hasAggregateValue
-    case 406: self = .hasAllowAlias
-    case 407: self = .hasBegin
-    case 408: self = .hasCcEnableArenas
-    case 409: self = .hasCcGenericServices
-    case 410: self = .hasClientStreaming
-    case 411: self = .hasCsharpNamespace
-    case 412: self = .hasCtype
-    case 413: self = .hasDebugRedact
-    case 414: self = .hasDefaultValue
-    case 415: self = .hasDeprecated
-    case 416: self = .hasDeprecatedLegacyJsonFieldConflicts
-    case 417: self = .hasDoubleValue
-    case 418: self = .hasEdition
-    case 419: self = .hasEnd
-    case 420: self = .hasEnumType
-    case 421: self = .hasExtendee
-    case 422: self = .hasExtensionValue
-    case 423: self = .hasFeatures
-    case 424: self = .hasFieldPresence
-    case 425: self = .hasFullName
-    case 426: self = .hasGoPackage
-    case 427: self = .hash
-    case 428: self = .hashable
-    case 429: self = .hasher
-    case 430: self = .hashVisitor
-    case 431: self = .hasIdempotencyLevel
-    case 432: self = .hasIdentifierValue
-    case 433: self = .hasInputType
-    case 434: self = .hasIsExtension
-    case 435: self = .hasJavaGenerateEqualsAndHash
-    case 436: self = .hasJavaGenericServices
-    case 437: self = .hasJavaMultipleFiles
-    case 438: self = .hasJavaOuterClassname
-    case 439: self = .hasJavaPackage
-    case 440: self = .hasJavaStringCheckUtf8
-    case 441: self = .hasJsonFormat
-    case 442: self = .hasJsonName
-    case 443: self = .hasJstype
-    case 444: self = .hasLabel
-    case 445: self = .hasLazy
-    case 446: self = .hasLeadingComments
-    case 447: self = .hasMapEntry
-    case 448: self = .hasMaximumEdition
-    case 449: self = .hasMessageEncoding
-    case 450: self = .hasMessageSetWireFormat
-    case 451: self = .hasMinimumEdition
-    case 452: self = .hasName
-    case 453: self = .hasNamePart
-    case 454: self = .hasNegativeIntValue
-    case 455: self = .hasNoStandardDescriptorAccessor
-    case 456: self = .hasNumber
-    case 457: self = .hasObjcClassPrefix
-    case 458: self = .hasOneofIndex
-    case 459: self = .hasOptimizeFor
-    case 460: self = .hasOptions
-    case 461: self = .hasOutputType
-    case 462: self = .hasPackage
-    case 463: self = .hasPacked
-    case 464: self = .hasPhpClassPrefix
-    case 465: self = .hasPhpGenericServices
-    case 466: self = .hasPhpMetadataNamespace
-    case 467: self = .hasPhpNamespace
-    case 468: self = .hasPositiveIntValue
-    case 469: self = .hasProto3Optional
-    case 470: self = .hasPyGenericServices
-    case 471: self = .hasRepeated
-    case 472: self = .hasRepeatedFieldEncoding
-    case 473: self = .hasReserved
-    case 474: self = .hasRetention
-    case 475: self = .hasRubyPackage
-    case 476: self = .hasSemantic
-    case 477: self = .hasServerStreaming
-    case 478: self = .hasSourceCodeInfo
-    case 479: self = .hasSourceContext
-    case 480: self = .hasSourceFile
-    case 481: self = .hasStart
-    case 482: self = .hasStringValue
-    case 483: self = .hasSwiftPrefix
-    case 484: self = .hasSyntax
-    case 485: self = .hasTrailingComments
-    case 486: self = .hasType
-    case 487: self = .hasTypeName
-    case 488: self = .hasUnverifiedLazy
-    case 489: self = .hasUtf8Validation
-    case 490: self = .hasValue
-    case 491: self = .hasVerification
-    case 492: self = .hasWeak
-    case 493: self = .hour
-    case 494: self = .i
-    case 495: self = .idempotencyLevel
-    case 496: self = .identifierValue
-    case 497: self = .if
-    case 498: self = .ignoreUnknownFields
-    case 499: self = .index
-    case 500: self = .init_
-    case 501: self = .inout
-    case 502: self = .inputType
-    case 503: self = .insert
-    case 504: self = .int
-    case 505: self = .int32
-    case 506: self = .int32Value
-    case 507: self = .int64
-    case 508: self = .int64Value
-    case 509: self = .int8
-    case 510: self = .integerLiteral
-    case 511: self = .integerLiteralType
-    case 512: self = .intern
-    case 513: self = .internal
-    case 514: self = .internalState
-    case 515: self = .into
-    case 516: self = .ints
-    case 517: self = .isA
-    case 518: self = .isEqual
-    case 519: self = .isEqualTo
-    case 520: self = .isExtension
-    case 521: self = .isInitialized
-    case 522: self = .isNegative
-    case 523: self = .itemTagsEncodedSize
-    case 524: self = .iterator
-    case 525: self = .javaGenerateEqualsAndHash
-    case 526: self = .javaGenericServices
-    case 527: self = .javaMultipleFiles
-    case 528: self = .javaOuterClassname
-    case 529: self = .javaPackage
-    case 530: self = .javaStringCheckUtf8
-    case 531: self = .jsondecoder
-    case 532: self = .jsondecodingError
-    case 533: self = .jsondecodingOptions
-    case 534: self = .jsonEncoder
-    case 535: self = .jsonencodingError
-    case 536: self = .jsonencodingOptions
-    case 537: self = .jsonencodingVisitor
-    case 538: self = .jsonFormat
-    case 539: self = .jsonmapEncodingVisitor
-    case 540: self = .jsonName
-    case 541: self = .jsonPath
-    case 542: self = .jsonPaths
-    case 543: self = .jsonscanner
-    case 544: self = .jsonString
-    case 545: self = .jsonText
-    case 546: self = .jsonUtf8Bytes
-    case 547: self = .jsonUtf8Data
-    case 548: self = .jstype
-    case 549: self = .k
-    case 550: self = .kChunkSize
-    case 551: self = .key
-    case 552: self = .keyField
-    case 553: self = .keyFieldOpt
-    case 554: self = .keyType
-    case 555: self = .kind
-    case 556: self = .l
-    case 557: self = .label
-    case 558: self = .lazy
-    case 559: self = .leadingComments
-    case 560: self = .leadingDetachedComments
-    case 561: self = .length
-    case 562: self = .lessThan
-    case 563: self = .let
-    case 564: self = .lhs
-    case 565: self = .list
-    case 566: self = .listOfMessages
-    case 567: self = .listValue
-    case 568: self = .littleEndian
-    case 569: self = .littleEndianBytes
-    case 570: self = .load
-    case 571: self = .localHasher
-    case 572: self = .location
-    case 573: self = .m
-    case 574: self = .major
-    case 575: self = .makeAsyncIterator
-    case 576: self = .makeIterator
-    case 577: self = .mapEntry
-    case 578: self = .mapKeyType
-    case 579: self = .mapToMessages
-    case 580: self = .mapValueType
-    case 581: self = .mapVisitor
-    case 582: self = .maximumEdition
-    case 583: self = .mdayStart
-    case 584: self = .merge
-    case 585: self = .message
-    case 586: self = .messageDepthLimit
-    case 587: self = .messageEncoding
-    case 588: self = .messageExtension
-    case 589: self = .messageImplementationBase
-    case 590: self = .messageOptions
-    case 591: self = .messageSet
-    case 592: self = .messageSetWireFormat
-    case 593: self = .messageSize
-    case 594: self = .messageType
-    case 595: self = .method
-    case 596: self = .methodDescriptorProto
-    case 597: self = .methodOptions
-    case 598: self = .methods
-    case 599: self = .min
-    case 600: self = .minimumEdition
-    case 601: self = .minor
-    case 602: self = .mixin
-    case 603: self = .mixins
-    case 604: self = .modifier
-    case 605: self = .modify
-    case 606: self = .month
-    case 607: self = .msgExtension
-    case 608: self = .mutating
-    case 609: self = .n
-    case 610: self = .name
-    case 611: self = .nameDescription
-    case 612: self = .nameMap
-    case 613: self = .namePart
-    case 614: self = .names
-    case 615: self = .nanos
-    case 616: self = .negativeIntValue
-    case 617: self = .nestedType
-    case 618: self = .newL
-    case 619: self = .newList
-    case 620: self = .newValue
-    case 621: self = .next
-    case 622: self = .nextByte
-    case 623: self = .nextFieldNumber
-    case 624: self = .nextVarInt
-    case 625: self = .nil
-    case 626: self = .nilLiteral
-    case 627: self = .noStandardDescriptorAccessor
-    case 628: self = .nullValue
-    case 629: self = .number
-    case 630: self = .numberValue
-    case 631: self = .objcClassPrefix
-    case 632: self = .of
-    case 633: self = .oneofDecl
-    case 634: self = .oneofDescriptorProto
-    case 635: self = .oneofIndex
-    case 636: self = .oneofOptions
-    case 637: self = .oneofs
-    case 638: self = .oneOfKind
-    case 639: self = .optimizeFor
-    case 640: self = .optimizeMode
-    case 641: self = .option
-    case 642: self = .optionalEnumExtensionField
-    case 643: self = .optionalExtensionField
-    case 644: self = .optionalGroupExtensionField
-    case 645: self = .optionalMessageExtensionField
-    case 646: self = .optionRetention
-    case 647: self = .options
-    case 648: self = .optionTargetType
-    case 649: self = .other
-    case 650: self = .others
-    case 651: self = .out
-    case 652: self = .outputType
-    case 653: self = .p
-    case 654: self = .package
-    case 655: self = .packed
-    case 656: self = .packedEnumExtensionField
-    case 657: self = .packedExtensionField
-    case 658: self = .padding
-    case 659: self = .parent
-    case 660: self = .parse
-    case 661: self = .path
-    case 662: self = .paths
-    case 663: self = .payload
-    case 664: self = .payloadSize
-    case 665: self = .phpClassPrefix
-    case 666: self = .phpGenericServices
-    case 667: self = .phpMetadataNamespace
-    case 668: self = .phpNamespace
-    case 669: self = .pos
-    case 670: self = .positiveIntValue
-    case 671: self = .prefix
-    case 672: self = .preserveProtoFieldNames
-    case 673: self = .preTraverse
-    case 674: self = .printUnknownFields
-    case 675: self = .proto2
-    case 676: self = .proto3DefaultValue
-    case 677: self = .proto3Optional
-    case 678: self = .protobufApiversionCheck
-    case 679: self = .protobufApiversion3
-    case 680: self = .protobufBool
-    case 681: self = .protobufBytes
-    case 682: self = .protobufDouble
-    case 683: self = .protobufEnumMap
-    case 684: self = .protobufExtension
-    case 685: self = .protobufFixed32
-    case 686: self = .protobufFixed64
-    case 687: self = .protobufFloat
-    case 688: self = .protobufInt32
-    case 689: self = .protobufInt64
-    case 690: self = .protobufMap
-    case 691: self = .protobufMessageMap
-    case 692: self = .protobufSfixed32
-    case 693: self = .protobufSfixed64
-    case 694: self = .protobufSint32
-    case 695: self = .protobufSint64
-    case 696: self = .protobufString
-    case 697: self = .protobufUint32
-    case 698: self = .protobufUint64
-    case 699: self = .protobufExtensionFieldValues
-    case 700: self = .protobufFieldNumber
-    case 701: self = .protobufGeneratedIsEqualTo
-    case 702: self = .protobufNameMap
-    case 703: self = .protobufNewField
-    case 704: self = .protobufPackage
-    case 705: self = .protocol
-    case 706: self = .protoFieldName
-    case 707: self = .protoMessageName
-    case 708: self = .protoNameProviding
-    case 709: self = .protoPaths
-    case 710: self = .public
-    case 711: self = .publicDependency
-    case 712: self = .putBoolValue
-    case 713: self = .putBytesValue
-    case 714: self = .putDoubleValue
-    case 715: self = .putEnumValue
-    case 716: self = .putFixedUint32
-    case 717: self = .putFixedUint64
-    case 718: self = .putFloatValue
-    case 719: self = .putInt64
-    case 720: self = .putStringValue
-    case 721: self = .putUint64
-    case 722: self = .putUint64Hex
-    case 723: self = .putVarInt
-    case 724: self = .putZigZagVarInt
-    case 725: self = .pyGenericServices
-    case 726: self = .r
-    case 727: self = .rawChars
-    case 728: self = .rawRepresentable
-    case 729: self = .rawValue_
-    case 730: self = .read4HexDigits
-    case 731: self = .readBytes
-    case 732: self = .register
-    case 733: self = .repeated
-    case 734: self = .repeatedEnumExtensionField
-    case 735: self = .repeatedExtensionField
-    case 736: self = .repeatedFieldEncoding
-    case 737: self = .repeatedGroupExtensionField
-    case 738: self = .repeatedMessageExtensionField
-    case 739: self = .repeating
-    case 740: self = .requestStreaming
-    case 741: self = .requestTypeURL
-    case 742: self = .requiredSize
-    case 743: self = .responseStreaming
-    case 744: self = .responseTypeURL
-    case 745: self = .result
-    case 746: self = .retention
-    case 747: self = .rethrows
-    case 748: self = .return
-    case 749: self = .returnType
-    case 750: self = .revision
-    case 751: self = .rhs
-    case 752: self = .root
-    case 753: self = .rubyPackage
-    case 754: self = .s
-    case 755: self = .sawBackslash
-    case 756: self = .sawSection4Characters
-    case 757: self = .sawSection5Characters
-    case 758: self = .scanner
-    case 759: self = .seconds
-    case 760: self = .self_
-    case 761: self = .semantic
-    case 762: self = .sendable
-    case 763: self = .separator
-    case 764: self = .serialize
-    case 765: self = .serializedBytes
-    case 766: self = .serializedData
-    case 767: self = .serializedSize
-    case 768: self = .serverStreaming
-    case 769: self = .service
-    case 770: self = .serviceDescriptorProto
-    case 771: self = .serviceOptions
-    case 772: self = .set
-    case 773: self = .setExtensionValue
-    case 774: self = .shift
-    case 775: self = .simpleExtensionMap
-    case 776: self = .size
-    case 777: self = .sizer
-    case 778: self = .source
-    case 779: self = .sourceCodeInfo
-    case 780: self = .sourceContext
-    case 781: self = .sourceEncoding
-    case 782: self = .sourceFile
-    case 783: self = .span
-    case 784: self = .split
-    case 785: self = .start
-    case 786: self = .startArray
-    case 787: self = .startArrayObject
-    case 788: self = .startField
-    case 789: self = .startIndex
-    case 790: self = .startMessageField
-    case 791: self = .startObject
-    case 792: self = .startRegularField
-    case 793: self = .state
-    case 794: self = .static
-    case 795: self = .staticString
-    case 796: self = .storage
-    case 797: self = .string
-    case 798: self = .stringLiteral
-    case 799: self = .stringLiteralType
-    case 800: self = .stringResult
-    case 801: self = .stringValue
-    case 802: self = .struct
-    case 803: self = .structValue
-    case 804: self = .subDecoder
-    case 805: self = .subscript
-    case 806: self = .subVisitor
-    case 807: self = .swift
-    case 808: self = .swiftPrefix
-    case 809: self = .swiftProtobufContiguousBytes
-    case 810: self = .syntax
-    case 811: self = .t
-    case 812: self = .tag
-    case 813: self = .targets
-    case 814: self = .terminator
-    case 815: self = .testDecoder
-    case 816: self = .text
-    case 817: self = .textDecoder
-    case 818: self = .textFormatDecoder
-    case 819: self = .textFormatDecodingError
-    case 820: self = .textFormatDecodingOptions
-    case 821: self = .textFormatEncodingOptions
-    case 822: self = .textFormatEncodingVisitor
-    case 823: self = .textFormatString
-    case 824: self = .throwOrIgnore
-    case 825: self = .throws
-    case 826: self = .timeInterval
-    case 827: self = .timeIntervalSince1970
-    case 828: self = .timeIntervalSinceReferenceDate
-    case 829: self = .timestamp
-    case 830: self = .total
-    case 831: self = .totalArrayDepth
-    case 832: self = .totalSize
-    case 833: self = .trailingComments
-    case 834: self = .traverse
-    case 835: self = .true
-    case 836: self = .try
-    case 837: self = .type
-    case 838: self = .typealias
-    case 839: self = .typeEnum
-    case 840: self = .typeName
-    case 841: self = .typePrefix
-    case 842: self = .typeStart
-    case 843: self = .typeUnknown
-    case 844: self = .typeURL
-    case 845: self = .uint32
-    case 846: self = .uint32Value
-    case 847: self = .uint64
-    case 848: self = .uint64Value
-    case 849: self = .uint8
-    case 850: self = .unchecked
-    case 851: self = .unicodeScalarLiteral
-    case 852: self = .unicodeScalarLiteralType
-    case 853: self = .unicodeScalars
-    case 854: self = .unicodeScalarView
-    case 855: self = .uninterpretedOption
-    case 856: self = .union
-    case 857: self = .uniqueStorage
-    case 858: self = .unknown
-    case 859: self = .unknownFields
-    case 860: self = .unknownStorage
-    case 861: self = .unpackTo
-    case 862: self = .unsafeBufferPointer
-    case 863: self = .unsafeMutablePointer
-    case 864: self = .unsafeMutableRawBufferPointer
-    case 865: self = .unsafeRawBufferPointer
-    case 866: self = .unsafeRawPointer
-    case 867: self = .unverifiedLazy
-    case 868: self = .updatedOptions
-    case 869: self = .url
-    case 870: self = .useDeterministicOrdering
-    case 871: self = .utf8
-    case 872: self = .utf8Ptr
-    case 873: self = .utf8ToDouble
-    case 874: self = .utf8Validation
-    case 875: self = .utf8View
-    case 876: self = .v
-    case 877: self = .value
-    case 878: self = .valueField
-    case 879: self = .values
-    case 880: self = .valueType
-    case 881: self = .var
-    case 882: self = .verification
-    case 883: self = .verificationState
-    case 884: self = .version
-    case 885: self = .versionString
-    case 886: self = .visitExtensionFields
-    case 887: self = .visitExtensionFieldsAsMessageSet
-    case 888: self = .visitMapField
-    case 889: self = .visitor
-    case 890: self = .visitPacked
-    case 891: self = .visitPackedBoolField
-    case 892: self = .visitPackedDoubleField
-    case 893: self = .visitPackedEnumField
-    case 894: self = .visitPackedFixed32Field
-    case 895: self = .visitPackedFixed64Field
-    case 896: self = .visitPackedFloatField
-    case 897: self = .visitPackedInt32Field
-    case 898: self = .visitPackedInt64Field
-    case 899: self = .visitPackedSfixed32Field
-    case 900: self = .visitPackedSfixed64Field
-    case 901: self = .visitPackedSint32Field
-    case 902: self = .visitPackedSint64Field
-    case 903: self = .visitPackedUint32Field
-    case 904: self = .visitPackedUint64Field
-    case 905: self = .visitRepeated
-    case 906: self = .visitRepeatedBoolField
-    case 907: self = .visitRepeatedBytesField
-    case 908: self = .visitRepeatedDoubleField
-    case 909: self = .visitRepeatedEnumField
-    case 910: self = .visitRepeatedFixed32Field
-    case 911: self = .visitRepeatedFixed64Field
-    case 912: self = .visitRepeatedFloatField
-    case 913: self = .visitRepeatedGroupField
-    case 914: self = .visitRepeatedInt32Field
-    case 915: self = .visitRepeatedInt64Field
-    case 916: self = .visitRepeatedMessageField
-    case 917: self = .visitRepeatedSfixed32Field
-    case 918: self = .visitRepeatedSfixed64Field
-    case 919: self = .visitRepeatedSint32Field
-    case 920: self = .visitRepeatedSint64Field
-    case 921: self = .visitRepeatedStringField
-    case 922: self = .visitRepeatedUint32Field
-    case 923: self = .visitRepeatedUint64Field
-    case 924: self = .visitSingular
-    case 925: self = .visitSingularBoolField
-    case 926: self = .visitSingularBytesField
-    case 927: self = .visitSingularDoubleField
-    case 928: self = .visitSingularEnumField
-    case 929: self = .visitSingularFixed32Field
-    case 930: self = .visitSingularFixed64Field
-    case 931: self = .visitSingularFloatField
-    case 932: self = .visitSingularGroupField
-    case 933: self = .visitSingularInt32Field
-    case 934: self = .visitSingularInt64Field
-    case 935: self = .visitSingularMessageField
-    case 936: self = .visitSingularSfixed32Field
-    case 937: self = .visitSingularSfixed64Field
-    case 938: self = .visitSingularSint32Field
-    case 939: self = .visitSingularSint64Field
-    case 940: self = .visitSingularStringField
-    case 941: self = .visitSingularUint32Field
-    case 942: self = .visitSingularUint64Field
-    case 943: self = .visitUnknown
-    case 944: self = .wasDecoded
-    case 945: self = .weak
-    case 946: self = .weakDependency
-    case 947: self = .where
-    case 948: self = .wireFormat
-    case 949: self = .with
-    case 950: self = .withUnsafeBytes
-    case 951: self = .withUnsafeMutableBytes
-    case 952: self = .work
-    case 953: self = .wrapped
-    case 954: self = .wrappedType
-    case 955: self = .wrappedValue
-    case 956: self = .written
-    case 957: self = .yday
+    case 278: self = .escaping
+    case 279: self = .expressibleByArrayLiteral
+    case 280: self = .expressibleByDictionaryLiteral
+    case 281: self = .ext
+    case 282: self = .extDecoder
+    case 283: self = .extendedGraphemeClusterLiteral
+    case 284: self = .extendedGraphemeClusterLiteralType
+    case 285: self = .extendee
+    case 286: self = .extensibleMessage
+    case 287: self = .extension
+    case 288: self = .extensionField
+    case 289: self = .extensionFieldNumber
+    case 290: self = .extensionFields
+    case 291: self = .extensionFieldsAsMessageSet
+    case 292: self = .extensionFieldValueSet
+    case 293: self = .extensionMap
+    case 294: self = .extensionRange
+    case 295: self = .extensionRangeOptions
+    case 296: self = .extensions
+    case 297: self = .extras
+    case 298: self = .f
+    case 299: self = .false
+    case 300: self = .features
+    case 301: self = .featureSet
+    case 302: self = .featureSetDefaults
+    case 303: self = .featureSetEditionDefault
+    case 304: self = .field
+    case 305: self = .fieldData
+    case 306: self = .fieldDescriptorProto
+    case 307: self = .fieldMask
+    case 308: self = .fieldName
+    case 309: self = .fieldNameCount
+    case 310: self = .fieldNum
+    case 311: self = .fieldNumber
+    case 312: self = .fieldNumberForProto
+    case 313: self = .fieldOptions
+    case 314: self = .fieldPresence
+    case 315: self = .fields
+    case 316: self = .fieldSize
+    case 317: self = .fieldTag
+    case 318: self = .fieldType
+    case 319: self = .file
+    case 320: self = .fileDescriptorProto
+    case 321: self = .fileDescriptorSet
+    case 322: self = .fileName
+    case 323: self = .fileOptions
+    case 324: self = .filter
+    case 325: self = .final
+    case 326: self = .first
+    case 327: self = .firstItem
+    case 328: self = .float
+    case 329: self = .floatLiteral
+    case 330: self = .floatLiteralType
+    case 331: self = .floatValue
+    case 332: self = .forMessageName
+    case 333: self = .formUnion
+    case 334: self = .forReadingFrom
+    case 335: self = .forTypeURL
+    case 336: self = .forwardParser
+    case 337: self = .forWritingInto
+    case 338: self = .from
+    case 339: self = .fromAscii2
+    case 340: self = .fromAscii4
+    case 341: self = .fromByteOffset
+    case 342: self = .fromHexDigit
+    case 343: self = .fullName
+    case 344: self = .func
+    case 345: self = .g
+    case 346: self = .generatedCodeInfo
+    case 347: self = .get
+    case 348: self = .getExtensionValue
+    case 349: self = .getValue
+    case 350: self = .googleapis
+    case 351: self = .googleProtobufAny
+    case 352: self = .googleProtobufApi
+    case 353: self = .googleProtobufBoolValue
+    case 354: self = .googleProtobufBytesValue
+    case 355: self = .googleProtobufDescriptorProto
+    case 356: self = .googleProtobufDoubleValue
+    case 357: self = .googleProtobufDuration
+    case 358: self = .googleProtobufEdition
+    case 359: self = .googleProtobufEmpty
+    case 360: self = .googleProtobufEnum
+    case 361: self = .googleProtobufEnumDescriptorProto
+    case 362: self = .googleProtobufEnumOptions
+    case 363: self = .googleProtobufEnumValue
+    case 364: self = .googleProtobufEnumValueDescriptorProto
+    case 365: self = .googleProtobufEnumValueOptions
+    case 366: self = .googleProtobufExtensionRangeOptions
+    case 367: self = .googleProtobufFeatureSet
+    case 368: self = .googleProtobufFeatureSetDefaults
+    case 369: self = .googleProtobufField
+    case 370: self = .googleProtobufFieldDescriptorProto
+    case 371: self = .googleProtobufFieldMask
+    case 372: self = .googleProtobufFieldOptions
+    case 373: self = .googleProtobufFileDescriptorProto
+    case 374: self = .googleProtobufFileDescriptorSet
+    case 375: self = .googleProtobufFileOptions
+    case 376: self = .googleProtobufFloatValue
+    case 377: self = .googleProtobufGeneratedCodeInfo
+    case 378: self = .googleProtobufInt32Value
+    case 379: self = .googleProtobufInt64Value
+    case 380: self = .googleProtobufListValue
+    case 381: self = .googleProtobufMessageOptions
+    case 382: self = .googleProtobufMethod
+    case 383: self = .googleProtobufMethodDescriptorProto
+    case 384: self = .googleProtobufMethodOptions
+    case 385: self = .googleProtobufMixin
+    case 386: self = .googleProtobufNullValue
+    case 387: self = .googleProtobufOneofDescriptorProto
+    case 388: self = .googleProtobufOneofOptions
+    case 389: self = .googleProtobufOption
+    case 390: self = .googleProtobufServiceDescriptorProto
+    case 391: self = .googleProtobufServiceOptions
+    case 392: self = .googleProtobufSourceCodeInfo
+    case 393: self = .googleProtobufSourceContext
+    case 394: self = .googleProtobufStringValue
+    case 395: self = .googleProtobufStruct
+    case 396: self = .googleProtobufSyntax
+    case 397: self = .googleProtobufTimestamp
+    case 398: self = .googleProtobufType
+    case 399: self = .googleProtobufUint32Value
+    case 400: self = .googleProtobufUint64Value
+    case 401: self = .googleProtobufUninterpretedOption
+    case 402: self = .googleProtobufValue
+    case 403: self = .goPackage
+    case 404: self = .group
+    case 405: self = .groupFieldNumberStack
+    case 406: self = .groupSize
+    case 407: self = .hadOneofValue
+    case 408: self = .handleConflictingOneOf
+    case 409: self = .hasAggregateValue
+    case 410: self = .hasAllowAlias
+    case 411: self = .hasBegin
+    case 412: self = .hasCcEnableArenas
+    case 413: self = .hasCcGenericServices
+    case 414: self = .hasClientStreaming
+    case 415: self = .hasCsharpNamespace
+    case 416: self = .hasCtype
+    case 417: self = .hasDebugRedact
+    case 418: self = .hasDefaultValue
+    case 419: self = .hasDeprecated
+    case 420: self = .hasDeprecatedLegacyJsonFieldConflicts
+    case 421: self = .hasDoubleValue
+    case 422: self = .hasEdition
+    case 423: self = .hasEnd
+    case 424: self = .hasEnumType
+    case 425: self = .hasExtendee
+    case 426: self = .hasExtensionValue
+    case 427: self = .hasFeatures
+    case 428: self = .hasFieldPresence
+    case 429: self = .hasFullName
+    case 430: self = .hasGoPackage
+    case 431: self = .hash
+    case 432: self = .hashable
+    case 433: self = .hasher
+    case 434: self = .hashVisitor
+    case 435: self = .hasIdempotencyLevel
+    case 436: self = .hasIdentifierValue
+    case 437: self = .hasInputType
+    case 438: self = .hasIsExtension
+    case 439: self = .hasJavaGenerateEqualsAndHash
+    case 440: self = .hasJavaGenericServices
+    case 441: self = .hasJavaMultipleFiles
+    case 442: self = .hasJavaOuterClassname
+    case 443: self = .hasJavaPackage
+    case 444: self = .hasJavaStringCheckUtf8
+    case 445: self = .hasJsonFormat
+    case 446: self = .hasJsonName
+    case 447: self = .hasJstype
+    case 448: self = .hasLabel
+    case 449: self = .hasLazy
+    case 450: self = .hasLeadingComments
+    case 451: self = .hasMapEntry
+    case 452: self = .hasMaximumEdition
+    case 453: self = .hasMessageEncoding
+    case 454: self = .hasMessageSetWireFormat
+    case 455: self = .hasMinimumEdition
+    case 456: self = .hasName
+    case 457: self = .hasNamePart
+    case 458: self = .hasNegativeIntValue
+    case 459: self = .hasNoStandardDescriptorAccessor
+    case 460: self = .hasNumber
+    case 461: self = .hasObjcClassPrefix
+    case 462: self = .hasOneofIndex
+    case 463: self = .hasOptimizeFor
+    case 464: self = .hasOptions
+    case 465: self = .hasOutputType
+    case 466: self = .hasPackage
+    case 467: self = .hasPacked
+    case 468: self = .hasPhpClassPrefix
+    case 469: self = .hasPhpGenericServices
+    case 470: self = .hasPhpMetadataNamespace
+    case 471: self = .hasPhpNamespace
+    case 472: self = .hasPositiveIntValue
+    case 473: self = .hasProto3Optional
+    case 474: self = .hasPyGenericServices
+    case 475: self = .hasRepeated
+    case 476: self = .hasRepeatedFieldEncoding
+    case 477: self = .hasReserved
+    case 478: self = .hasRetention
+    case 479: self = .hasRubyPackage
+    case 480: self = .hasSemantic
+    case 481: self = .hasServerStreaming
+    case 482: self = .hasSourceCodeInfo
+    case 483: self = .hasSourceContext
+    case 484: self = .hasSourceFile
+    case 485: self = .hasStart
+    case 486: self = .hasStringValue
+    case 487: self = .hasSwiftPrefix
+    case 488: self = .hasSyntax
+    case 489: self = .hasTrailingComments
+    case 490: self = .hasType
+    case 491: self = .hasTypeName
+    case 492: self = .hasUnverifiedLazy
+    case 493: self = .hasUtf8Validation
+    case 494: self = .hasValue
+    case 495: self = .hasVerification
+    case 496: self = .hasWeak
+    case 497: self = .hour
+    case 498: self = .i
+    case 499: self = .idempotencyLevel
+    case 500: self = .identifierValue
+    case 501: self = .if
+    case 502: self = .ignoreUnknownFields
+    case 503: self = .index
+    case 504: self = .init_
+    case 505: self = .inout
+    case 506: self = .inputType
+    case 507: self = .insert
+    case 508: self = .int
+    case 509: self = .int32
+    case 510: self = .int32Value
+    case 511: self = .int64
+    case 512: self = .int64Value
+    case 513: self = .int8
+    case 514: self = .integerLiteral
+    case 515: self = .integerLiteralType
+    case 516: self = .intern
+    case 517: self = .internal
+    case 518: self = .internalState
+    case 519: self = .into
+    case 520: self = .ints
+    case 521: self = .isA
+    case 522: self = .isEqual
+    case 523: self = .isEqualTo
+    case 524: self = .isExtension
+    case 525: self = .isInitialized
+    case 526: self = .isNegative
+    case 527: self = .isUnset
+    case 528: self = .itemTagsEncodedSize
+    case 529: self = .iterator
+    case 530: self = .javaGenerateEqualsAndHash
+    case 531: self = .javaGenericServices
+    case 532: self = .javaMultipleFiles
+    case 533: self = .javaOuterClassname
+    case 534: self = .javaPackage
+    case 535: self = .javaStringCheckUtf8
+    case 536: self = .jsondecoder
+    case 537: self = .jsondecodingError
+    case 538: self = .jsondecodingOptions
+    case 539: self = .jsonEncoder
+    case 540: self = .jsonencodingError
+    case 541: self = .jsonencodingOptions
+    case 542: self = .jsonencodingVisitor
+    case 543: self = .jsonFormat
+    case 544: self = .jsonmapEncodingVisitor
+    case 545: self = .jsonName
+    case 546: self = .jsonPath
+    case 547: self = .jsonPaths
+    case 548: self = .jsonscanner
+    case 549: self = .jsonString
+    case 550: self = .jsonText
+    case 551: self = .jsonUtf8Bytes
+    case 552: self = .jsonUtf8Data
+    case 553: self = .jstype
+    case 554: self = .k
+    case 555: self = .kChunkSize
+    case 556: self = .key
+    case 557: self = .keyField
+    case 558: self = .keyFieldOpt
+    case 559: self = .keyType
+    case 560: self = .kind
+    case 561: self = .l
+    case 562: self = .label
+    case 563: self = .lazy
+    case 564: self = .leadingComments
+    case 565: self = .leadingDetachedComments
+    case 566: self = .length
+    case 567: self = .lessThan
+    case 568: self = .let
+    case 569: self = .lhs
+    case 570: self = .list
+    case 571: self = .listOfMessages
+    case 572: self = .listValue
+    case 573: self = .littleEndian
+    case 574: self = .littleEndianBytes
+    case 575: self = .load
+    case 576: self = .localHasher
+    case 577: self = .location
+    case 578: self = .m
+    case 579: self = .major
+    case 580: self = .makeAsyncIterator
+    case 581: self = .makeIterator
+    case 582: self = .map
+    case 583: self = .mapEntry
+    case 584: self = .mapKeyType
+    case 585: self = .mapToMessages
+    case 586: self = .mapValueType
+    case 587: self = .mapVisitor
+    case 588: self = .maximumEdition
+    case 589: self = .mdayStart
+    case 590: self = .merge
+    case 591: self = .message
+    case 592: self = .messageDepthLimit
+    case 593: self = .messageEncoding
+    case 594: self = .messageExtension
+    case 595: self = .messageImplementationBase
+    case 596: self = .messageOptions
+    case 597: self = .messageSet
+    case 598: self = .messageSetWireFormat
+    case 599: self = .messageSize
+    case 600: self = .messageType
+    case 601: self = .method
+    case 602: self = .methodDescriptorProto
+    case 603: self = .methodOptions
+    case 604: self = .methods
+    case 605: self = .min
+    case 606: self = .minimumEdition
+    case 607: self = .minor
+    case 608: self = .mixin
+    case 609: self = .mixins
+    case 610: self = .modifier
+    case 611: self = .modify
+    case 612: self = .month
+    case 613: self = .msgExtension
+    case 614: self = .mutating
+    case 615: self = .n
+    case 616: self = .name
+    case 617: self = .nameDescription
+    case 618: self = .nameMap
+    case 619: self = .namePart
+    case 620: self = .names
+    case 621: self = .nanos
+    case 622: self = .negativeIntValue
+    case 623: self = .nestedType
+    case 624: self = .newL
+    case 625: self = .newList
+    case 626: self = .newValue
+    case 627: self = .next
+    case 628: self = .nextByte
+    case 629: self = .nextFieldNumber
+    case 630: self = .nextVarInt
+    case 631: self = .nil
+    case 632: self = .nilLiteral
+    case 633: self = .noStandardDescriptorAccessor
+    case 634: self = .nullValue
+    case 635: self = .number
+    case 636: self = .numberValue
+    case 637: self = .objcClassPrefix
+    case 638: self = .of
+    case 639: self = .oneOf
+    case 640: self = .oneofDecl
+    case 641: self = .oneofDescriptorProto
+    case 642: self = .oneofIndex
+    case 643: self = .oneofOptions
+    case 644: self = .oneofs
+    case 645: self = .oneOfKind
+    case 646: self = .optimizeFor
+    case 647: self = .optimizeMode
+    case 648: self = .option
+    case 649: self = .optionalEnumExtensionField
+    case 650: self = .optionalExtensionField
+    case 651: self = .optionalGroupExtensionField
+    case 652: self = .optionalMessageExtensionField
+    case 653: self = .optionRetention
+    case 654: self = .options
+    case 655: self = .optionTargetType
+    case 656: self = .other
+    case 657: self = .others
+    case 658: self = .out
+    case 659: self = .outputType
+    case 660: self = .p
+    case 661: self = .package
+    case 662: self = .packed
+    case 663: self = .packedBool
+    case 664: self = .packedDouble
+    case 665: self = .packedEnum
+    case 666: self = .packedEnumExtensionField
+    case 667: self = .packedExtensionField
+    case 668: self = .packedFixed32
+    case 669: self = .packedFixed64
+    case 670: self = .packedFloat
+    case 671: self = .packedInt32
+    case 672: self = .packedInt64
+    case 673: self = .packedSfixed32
+    case 674: self = .packedSfixed64
+    case 675: self = .packedSint32
+    case 676: self = .packedSint64
+    case 677: self = .packedUint32
+    case 678: self = .packedUint64
+    case 679: self = .padding
+    case 680: self = .parent
+    case 681: self = .parse
+    case 682: self = .path
+    case 683: self = .paths
+    case 684: self = .payload
+    case 685: self = .payloadSize
+    case 686: self = .phpClassPrefix
+    case 687: self = .phpGenericServices
+    case 688: self = .phpMetadataNamespace
+    case 689: self = .phpNamespace
+    case 690: self = .pos
+    case 691: self = .positiveIntValue
+    case 692: self = .prefix
+    case 693: self = .preserveProtoFieldNames
+    case 694: self = .preTraverse
+    case 695: self = .printUnknownFields
+    case 696: self = .proto2
+    case 697: self = .proto3DefaultValue
+    case 698: self = .proto3Optional
+    case 699: self = .protobufApiversionCheck
+    case 700: self = .protobufApiversion3
+    case 701: self = .protobufBool
+    case 702: self = .protobufBytes
+    case 703: self = .protobufDouble
+    case 704: self = .protobufEnumMap
+    case 705: self = .protobufExtension
+    case 706: self = .protobufFixed32
+    case 707: self = .protobufFixed64
+    case 708: self = .protobufFloat
+    case 709: self = .protobufInt32
+    case 710: self = .protobufInt64
+    case 711: self = .protobufMap
+    case 712: self = .protobufMessageMap
+    case 713: self = .protobufSfixed32
+    case 714: self = .protobufSfixed64
+    case 715: self = .protobufSint32
+    case 716: self = .protobufSint64
+    case 717: self = .protobufString
+    case 718: self = .protobufUint32
+    case 719: self = .protobufUint64
+    case 720: self = .protobufExtensionFieldValues
+    case 721: self = .protobufFieldNumber
+    case 722: self = .protobufGeneratedIsEqualTo
+    case 723: self = .protobufNameMap
+    case 724: self = .protobufNewField
+    case 725: self = .protobufPackage
+    case 726: self = .protocol
+    case 727: self = .protoFieldName
+    case 728: self = .protoMessageName
+    case 729: self = .protoNameProviding
+    case 730: self = .protoPaths
+    case 731: self = .public
+    case 732: self = .publicDependency
+    case 733: self = .putBoolValue
+    case 734: self = .putBytesValue
+    case 735: self = .putDoubleValue
+    case 736: self = .putEnumValue
+    case 737: self = .putFixedUint32
+    case 738: self = .putFixedUint64
+    case 739: self = .putFloatValue
+    case 740: self = .putInt64
+    case 741: self = .putStringValue
+    case 742: self = .putUint64
+    case 743: self = .putUint64Hex
+    case 744: self = .putVarInt
+    case 745: self = .putZigZagVarInt
+    case 746: self = .pyGenericServices
+    case 747: self = .r
+    case 748: self = .rawChars
+    case 749: self = .rawRepresentable
+    case 750: self = .rawValue_
+    case 751: self = .read4HexDigits
+    case 752: self = .readBytes
+    case 753: self = .register
+    case 754: self = .repeated
+    case 755: self = .repeatedBool
+    case 756: self = .repeatedBytes
+    case 757: self = .repeatedDouble
+    case 758: self = .repeatedEnum
+    case 759: self = .repeatedEnumExtensionField
+    case 760: self = .repeatedExtensionField
+    case 761: self = .repeatedFieldEncoding
+    case 762: self = .repeatedFixed32
+    case 763: self = .repeatedFixed64
+    case 764: self = .repeatedFloat
+    case 765: self = .repeatedGroup
+    case 766: self = .repeatedGroupExtensionField
+    case 767: self = .repeatedInt32
+    case 768: self = .repeatedInt64
+    case 769: self = .repeatedMessage
+    case 770: self = .repeatedMessageExtensionField
+    case 771: self = .repeatedSfixed32
+    case 772: self = .repeatedSfixed64
+    case 773: self = .repeatedSint32
+    case 774: self = .repeatedSint64
+    case 775: self = .repeatedString
+    case 776: self = .repeatedUint32
+    case 777: self = .repeatedUint64
+    case 778: self = .repeating
+    case 779: self = .requestStreaming
+    case 780: self = .requestTypeURL
+    case 781: self = .requiredSize
+    case 782: self = .responseStreaming
+    case 783: self = .responseTypeURL
+    case 784: self = .result
+    case 785: self = .retention
+    case 786: self = .rethrows
+    case 787: self = .return
+    case 788: self = .returnType
+    case 789: self = .revision
+    case 790: self = .rhs
+    case 791: self = .root
+    case 792: self = .rubyPackage
+    case 793: self = .s
+    case 794: self = .sawBackslash
+    case 795: self = .sawSection4Characters
+    case 796: self = .sawSection5Characters
+    case 797: self = .scanner
+    case 798: self = .seconds
+    case 799: self = .self_
+    case 800: self = .semantic
+    case 801: self = .sendable
+    case 802: self = .separator
+    case 803: self = .serialize
+    case 804: self = .serializedBytes
+    case 805: self = .serializedData
+    case 806: self = .serializedSize
+    case 807: self = .serverStreaming
+    case 808: self = .service
+    case 809: self = .serviceDescriptorProto
+    case 810: self = .serviceOptions
+    case 811: self = .set
+    case 812: self = .setExtensionValue
+    case 813: self = .shift
+    case 814: self = .simpleExtensionMap
+    case 815: self = .singularBool
+    case 816: self = .singularBytes
+    case 817: self = .singularDouble
+    case 818: self = .singularEnum
+    case 819: self = .singularFixed32
+    case 820: self = .singularFixed64
+    case 821: self = .singularFloat
+    case 822: self = .singularGroup
+    case 823: self = .singularInt32
+    case 824: self = .singularInt64
+    case 825: self = .singularMessage
+    case 826: self = .singularSfixed32
+    case 827: self = .singularSfixed64
+    case 828: self = .singularSint32
+    case 829: self = .singularSint64
+    case 830: self = .singularString
+    case 831: self = .singularUint32
+    case 832: self = .singularUint64
+    case 833: self = .size
+    case 834: self = .sizer
+    case 835: self = .source
+    case 836: self = .sourceCodeInfo
+    case 837: self = .sourceContext
+    case 838: self = .sourceEncoding
+    case 839: self = .sourceFile
+    case 840: self = .span
+    case 841: self = .split
+    case 842: self = .start
+    case 843: self = .startArray
+    case 844: self = .startArrayObject
+    case 845: self = .startField
+    case 846: self = .startIndex
+    case 847: self = .startMessageField
+    case 848: self = .startObject
+    case 849: self = .startRegularField
+    case 850: self = .state
+    case 851: self = .static
+    case 852: self = .staticString
+    case 853: self = .storage
+    case 854: self = .string
+    case 855: self = .stringLiteral
+    case 856: self = .stringLiteralType
+    case 857: self = .stringResult
+    case 858: self = .stringValue
+    case 859: self = .struct
+    case 860: self = .structValue
+    case 861: self = .subDecoder
+    case 862: self = .subscript
+    case 863: self = .subVisitor
+    case 864: self = .swift
+    case 865: self = .swiftPrefix
+    case 866: self = .swiftProtobufContiguousBytes
+    case 867: self = .syntax
+    case 868: self = .t
+    case 869: self = .tag
+    case 870: self = .targets
+    case 871: self = .terminator
+    case 872: self = .testDecoder
+    case 873: self = .text
+    case 874: self = .textDecoder
+    case 875: self = .textFormatDecoder
+    case 876: self = .textFormatDecodingError
+    case 877: self = .textFormatDecodingOptions
+    case 878: self = .textFormatEncodingOptions
+    case 879: self = .textFormatEncodingVisitor
+    case 880: self = .textFormatString
+    case 881: self = .throwOrIgnore
+    case 882: self = .throws
+    case 883: self = .timeInterval
+    case 884: self = .timeIntervalSince1970
+    case 885: self = .timeIntervalSinceReferenceDate
+    case 886: self = .timestamp
+    case 887: self = .toConcrete
+    case 888: self = .total
+    case 889: self = .totalArrayDepth
+    case 890: self = .totalSize
+    case 891: self = .trailingComments
+    case 892: self = .traverse
+    case 893: self = .true
+    case 894: self = .try
+    case 895: self = .type
+    case 896: self = .typealias
+    case 897: self = .typeEnum
+    case 898: self = .typeName
+    case 899: self = .typePrefix
+    case 900: self = .typeStart
+    case 901: self = .typeUnknown
+    case 902: self = .typeURL
+    case 903: self = .uint32
+    case 904: self = .uint32Value
+    case 905: self = .uint64
+    case 906: self = .uint64Value
+    case 907: self = .uint8
+    case 908: self = .unchecked
+    case 909: self = .unicodeScalarLiteral
+    case 910: self = .unicodeScalarLiteralType
+    case 911: self = .unicodeScalars
+    case 912: self = .unicodeScalarView
+    case 913: self = .uninterpretedOption
+    case 914: self = .union
+    case 915: self = .uniqueStorage
+    case 916: self = .unknown
+    case 917: self = .unknownFields
+    case 918: self = .unknownStorage
+    case 919: self = .unpackTo
+    case 920: self = .unsafeBufferPointer
+    case 921: self = .unsafeMutablePointer
+    case 922: self = .unsafeMutableRawBufferPointer
+    case 923: self = .unsafeRawBufferPointer
+    case 924: self = .unsafeRawPointer
+    case 925: self = .unverifiedLazy
+    case 926: self = .updatedOptions
+    case 927: self = .url
+    case 928: self = .useDeterministicOrdering
+    case 929: self = .utf8
+    case 930: self = .utf8Ptr
+    case 931: self = .utf8ToDouble
+    case 932: self = .utf8Validation
+    case 933: self = .utf8View
+    case 934: self = .v
+    case 935: self = .value
+    case 936: self = .valueField
+    case 937: self = .values
+    case 938: self = .valueType
+    case 939: self = .var
+    case 940: self = .verification
+    case 941: self = .verificationState
+    case 942: self = .version
+    case 943: self = .versionString
+    case 944: self = .visitExtensionFields
+    case 945: self = .visitExtensionFieldsAsMessageSet
+    case 946: self = .visitMapField
+    case 947: self = .visitor
+    case 948: self = .visitPacked
+    case 949: self = .visitPackedBoolField
+    case 950: self = .visitPackedDoubleField
+    case 951: self = .visitPackedEnumField
+    case 952: self = .visitPackedFixed32Field
+    case 953: self = .visitPackedFixed64Field
+    case 954: self = .visitPackedFloatField
+    case 955: self = .visitPackedInt32Field
+    case 956: self = .visitPackedInt64Field
+    case 957: self = .visitPackedSfixed32Field
+    case 958: self = .visitPackedSfixed64Field
+    case 959: self = .visitPackedSint32Field
+    case 960: self = .visitPackedSint64Field
+    case 961: self = .visitPackedUint32Field
+    case 962: self = .visitPackedUint64Field
+    case 963: self = .visitRepeated
+    case 964: self = .visitRepeatedBoolField
+    case 965: self = .visitRepeatedBytesField
+    case 966: self = .visitRepeatedDoubleField
+    case 967: self = .visitRepeatedEnumField
+    case 968: self = .visitRepeatedFixed32Field
+    case 969: self = .visitRepeatedFixed64Field
+    case 970: self = .visitRepeatedFloatField
+    case 971: self = .visitRepeatedGroupField
+    case 972: self = .visitRepeatedInt32Field
+    case 973: self = .visitRepeatedInt64Field
+    case 974: self = .visitRepeatedMessageField
+    case 975: self = .visitRepeatedSfixed32Field
+    case 976: self = .visitRepeatedSfixed64Field
+    case 977: self = .visitRepeatedSint32Field
+    case 978: self = .visitRepeatedSint64Field
+    case 979: self = .visitRepeatedStringField
+    case 980: self = .visitRepeatedUint32Field
+    case 981: self = .visitRepeatedUint64Field
+    case 982: self = .visitSingular
+    case 983: self = .visitSingularBoolField
+    case 984: self = .visitSingularBytesField
+    case 985: self = .visitSingularDoubleField
+    case 986: self = .visitSingularEnumField
+    case 987: self = .visitSingularFixed32Field
+    case 988: self = .visitSingularFixed64Field
+    case 989: self = .visitSingularFloatField
+    case 990: self = .visitSingularGroupField
+    case 991: self = .visitSingularInt32Field
+    case 992: self = .visitSingularInt64Field
+    case 993: self = .visitSingularMessageField
+    case 994: self = .visitSingularSfixed32Field
+    case 995: self = .visitSingularSfixed64Field
+    case 996: self = .visitSingularSint32Field
+    case 997: self = .visitSingularSint64Field
+    case 998: self = .visitSingularStringField
+    case 999: self = .visitSingularUint32Field
+    case 1000: self = .visitSingularUint64Field
+    case 1001: self = .visitUnknown
+    case 1002: self = .wasDecoded
+    case 1003: self = .weak
+    case 1004: self = .weakDependency
+    case 1005: self = .where
+    case 1006: self = .wireFormat
+    case 1007: self = .with
+    case 1008: self = .withUnsafeBytes
+    case 1009: self = .withUnsafeMutableBytes
+    case 1010: self = .work
+    case 1011: self = .wrapped
+    case 1012: self = .wrappedType
+    case 1013: self = .wrappedValue
+    case 1014: self = .written
+    case 1015: self = .yday
     default: self = .UNRECOGNIZED(rawValue)
     }
   }
@@ -2234,689 +2350,750 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     case .enumValueOptions: return 275
     case .equatable: return 276
     case .error: return 277
-    case .expressibleByArrayLiteral: return 278
-    case .expressibleByDictionaryLiteral: return 279
-    case .ext: return 280
-    case .extDecoder: return 281
-    case .extendedGraphemeClusterLiteral: return 282
-    case .extendedGraphemeClusterLiteralType: return 283
-    case .extendee: return 284
-    case .extensibleMessage: return 285
-    case .extension: return 286
-    case .extensionField: return 287
-    case .extensionFieldNumber: return 288
-    case .extensionFieldValueSet: return 289
-    case .extensionMap: return 290
-    case .extensionRange: return 291
-    case .extensionRangeOptions: return 292
-    case .extensions: return 293
-    case .extras: return 294
-    case .f: return 295
-    case .false: return 296
-    case .features: return 297
-    case .featureSet: return 298
-    case .featureSetDefaults: return 299
-    case .featureSetEditionDefault: return 300
-    case .field: return 301
-    case .fieldData: return 302
-    case .fieldDescriptorProto: return 303
-    case .fieldMask: return 304
-    case .fieldName: return 305
-    case .fieldNameCount: return 306
-    case .fieldNum: return 307
-    case .fieldNumber: return 308
-    case .fieldNumberForProto: return 309
-    case .fieldOptions: return 310
-    case .fieldPresence: return 311
-    case .fields: return 312
-    case .fieldSize: return 313
-    case .fieldTag: return 314
-    case .fieldType: return 315
-    case .file: return 316
-    case .fileDescriptorProto: return 317
-    case .fileDescriptorSet: return 318
-    case .fileName: return 319
-    case .fileOptions: return 320
-    case .filter: return 321
-    case .final: return 322
-    case .first: return 323
-    case .firstItem: return 324
-    case .float: return 325
-    case .floatLiteral: return 326
-    case .floatLiteralType: return 327
-    case .floatValue: return 328
-    case .forMessageName: return 329
-    case .formUnion: return 330
-    case .forReadingFrom: return 331
-    case .forTypeURL: return 332
-    case .forwardParser: return 333
-    case .forWritingInto: return 334
-    case .from: return 335
-    case .fromAscii2: return 336
-    case .fromAscii4: return 337
-    case .fromByteOffset: return 338
-    case .fromHexDigit: return 339
-    case .fullName: return 340
-    case .func: return 341
-    case .g: return 342
-    case .generatedCodeInfo: return 343
-    case .get: return 344
-    case .getExtensionValue: return 345
-    case .googleapis: return 346
-    case .googleProtobufAny: return 347
-    case .googleProtobufApi: return 348
-    case .googleProtobufBoolValue: return 349
-    case .googleProtobufBytesValue: return 350
-    case .googleProtobufDescriptorProto: return 351
-    case .googleProtobufDoubleValue: return 352
-    case .googleProtobufDuration: return 353
-    case .googleProtobufEdition: return 354
-    case .googleProtobufEmpty: return 355
-    case .googleProtobufEnum: return 356
-    case .googleProtobufEnumDescriptorProto: return 357
-    case .googleProtobufEnumOptions: return 358
-    case .googleProtobufEnumValue: return 359
-    case .googleProtobufEnumValueDescriptorProto: return 360
-    case .googleProtobufEnumValueOptions: return 361
-    case .googleProtobufExtensionRangeOptions: return 362
-    case .googleProtobufFeatureSet: return 363
-    case .googleProtobufFeatureSetDefaults: return 364
-    case .googleProtobufField: return 365
-    case .googleProtobufFieldDescriptorProto: return 366
-    case .googleProtobufFieldMask: return 367
-    case .googleProtobufFieldOptions: return 368
-    case .googleProtobufFileDescriptorProto: return 369
-    case .googleProtobufFileDescriptorSet: return 370
-    case .googleProtobufFileOptions: return 371
-    case .googleProtobufFloatValue: return 372
-    case .googleProtobufGeneratedCodeInfo: return 373
-    case .googleProtobufInt32Value: return 374
-    case .googleProtobufInt64Value: return 375
-    case .googleProtobufListValue: return 376
-    case .googleProtobufMessageOptions: return 377
-    case .googleProtobufMethod: return 378
-    case .googleProtobufMethodDescriptorProto: return 379
-    case .googleProtobufMethodOptions: return 380
-    case .googleProtobufMixin: return 381
-    case .googleProtobufNullValue: return 382
-    case .googleProtobufOneofDescriptorProto: return 383
-    case .googleProtobufOneofOptions: return 384
-    case .googleProtobufOption: return 385
-    case .googleProtobufServiceDescriptorProto: return 386
-    case .googleProtobufServiceOptions: return 387
-    case .googleProtobufSourceCodeInfo: return 388
-    case .googleProtobufSourceContext: return 389
-    case .googleProtobufStringValue: return 390
-    case .googleProtobufStruct: return 391
-    case .googleProtobufSyntax: return 392
-    case .googleProtobufTimestamp: return 393
-    case .googleProtobufType: return 394
-    case .googleProtobufUint32Value: return 395
-    case .googleProtobufUint64Value: return 396
-    case .googleProtobufUninterpretedOption: return 397
-    case .googleProtobufValue: return 398
-    case .goPackage: return 399
-    case .group: return 400
-    case .groupFieldNumberStack: return 401
-    case .groupSize: return 402
-    case .hadOneofValue: return 403
-    case .handleConflictingOneOf: return 404
-    case .hasAggregateValue: return 405
-    case .hasAllowAlias: return 406
-    case .hasBegin: return 407
-    case .hasCcEnableArenas: return 408
-    case .hasCcGenericServices: return 409
-    case .hasClientStreaming: return 410
-    case .hasCsharpNamespace: return 411
-    case .hasCtype: return 412
-    case .hasDebugRedact: return 413
-    case .hasDefaultValue: return 414
-    case .hasDeprecated: return 415
-    case .hasDeprecatedLegacyJsonFieldConflicts: return 416
-    case .hasDoubleValue: return 417
-    case .hasEdition: return 418
-    case .hasEnd: return 419
-    case .hasEnumType: return 420
-    case .hasExtendee: return 421
-    case .hasExtensionValue: return 422
-    case .hasFeatures: return 423
-    case .hasFieldPresence: return 424
-    case .hasFullName: return 425
-    case .hasGoPackage: return 426
-    case .hash: return 427
-    case .hashable: return 428
-    case .hasher: return 429
-    case .hashVisitor: return 430
-    case .hasIdempotencyLevel: return 431
-    case .hasIdentifierValue: return 432
-    case .hasInputType: return 433
-    case .hasIsExtension: return 434
-    case .hasJavaGenerateEqualsAndHash: return 435
-    case .hasJavaGenericServices: return 436
-    case .hasJavaMultipleFiles: return 437
-    case .hasJavaOuterClassname: return 438
-    case .hasJavaPackage: return 439
-    case .hasJavaStringCheckUtf8: return 440
-    case .hasJsonFormat: return 441
-    case .hasJsonName: return 442
-    case .hasJstype: return 443
-    case .hasLabel: return 444
-    case .hasLazy: return 445
-    case .hasLeadingComments: return 446
-    case .hasMapEntry: return 447
-    case .hasMaximumEdition: return 448
-    case .hasMessageEncoding: return 449
-    case .hasMessageSetWireFormat: return 450
-    case .hasMinimumEdition: return 451
-    case .hasName: return 452
-    case .hasNamePart: return 453
-    case .hasNegativeIntValue: return 454
-    case .hasNoStandardDescriptorAccessor: return 455
-    case .hasNumber: return 456
-    case .hasObjcClassPrefix: return 457
-    case .hasOneofIndex: return 458
-    case .hasOptimizeFor: return 459
-    case .hasOptions: return 460
-    case .hasOutputType: return 461
-    case .hasPackage: return 462
-    case .hasPacked: return 463
-    case .hasPhpClassPrefix: return 464
-    case .hasPhpGenericServices: return 465
-    case .hasPhpMetadataNamespace: return 466
-    case .hasPhpNamespace: return 467
-    case .hasPositiveIntValue: return 468
-    case .hasProto3Optional: return 469
-    case .hasPyGenericServices: return 470
-    case .hasRepeated: return 471
-    case .hasRepeatedFieldEncoding: return 472
-    case .hasReserved: return 473
-    case .hasRetention: return 474
-    case .hasRubyPackage: return 475
-    case .hasSemantic: return 476
-    case .hasServerStreaming: return 477
-    case .hasSourceCodeInfo: return 478
-    case .hasSourceContext: return 479
-    case .hasSourceFile: return 480
-    case .hasStart: return 481
-    case .hasStringValue: return 482
-    case .hasSwiftPrefix: return 483
-    case .hasSyntax: return 484
-    case .hasTrailingComments: return 485
-    case .hasType: return 486
-    case .hasTypeName: return 487
-    case .hasUnverifiedLazy: return 488
-    case .hasUtf8Validation: return 489
-    case .hasValue: return 490
-    case .hasVerification: return 491
-    case .hasWeak: return 492
-    case .hour: return 493
-    case .i: return 494
-    case .idempotencyLevel: return 495
-    case .identifierValue: return 496
-    case .if: return 497
-    case .ignoreUnknownFields: return 498
-    case .index: return 499
+    case .escaping: return 278
+    case .expressibleByArrayLiteral: return 279
+    case .expressibleByDictionaryLiteral: return 280
+    case .ext: return 281
+    case .extDecoder: return 282
+    case .extendedGraphemeClusterLiteral: return 283
+    case .extendedGraphemeClusterLiteralType: return 284
+    case .extendee: return 285
+    case .extensibleMessage: return 286
+    case .extension: return 287
+    case .extensionField: return 288
+    case .extensionFieldNumber: return 289
+    case .extensionFields: return 290
+    case .extensionFieldsAsMessageSet: return 291
+    case .extensionFieldValueSet: return 292
+    case .extensionMap: return 293
+    case .extensionRange: return 294
+    case .extensionRangeOptions: return 295
+    case .extensions: return 296
+    case .extras: return 297
+    case .f: return 298
+    case .false: return 299
+    case .features: return 300
+    case .featureSet: return 301
+    case .featureSetDefaults: return 302
+    case .featureSetEditionDefault: return 303
+    case .field: return 304
+    case .fieldData: return 305
+    case .fieldDescriptorProto: return 306
+    case .fieldMask: return 307
+    case .fieldName: return 308
+    case .fieldNameCount: return 309
+    case .fieldNum: return 310
+    case .fieldNumber: return 311
+    case .fieldNumberForProto: return 312
+    case .fieldOptions: return 313
+    case .fieldPresence: return 314
+    case .fields: return 315
+    case .fieldSize: return 316
+    case .fieldTag: return 317
+    case .fieldType: return 318
+    case .file: return 319
+    case .fileDescriptorProto: return 320
+    case .fileDescriptorSet: return 321
+    case .fileName: return 322
+    case .fileOptions: return 323
+    case .filter: return 324
+    case .final: return 325
+    case .first: return 326
+    case .firstItem: return 327
+    case .float: return 328
+    case .floatLiteral: return 329
+    case .floatLiteralType: return 330
+    case .floatValue: return 331
+    case .forMessageName: return 332
+    case .formUnion: return 333
+    case .forReadingFrom: return 334
+    case .forTypeURL: return 335
+    case .forwardParser: return 336
+    case .forWritingInto: return 337
+    case .from: return 338
+    case .fromAscii2: return 339
+    case .fromAscii4: return 340
+    case .fromByteOffset: return 341
+    case .fromHexDigit: return 342
+    case .fullName: return 343
+    case .func: return 344
+    case .g: return 345
+    case .generatedCodeInfo: return 346
+    case .get: return 347
+    case .getExtensionValue: return 348
+    case .getValue: return 349
+    case .googleapis: return 350
+    case .googleProtobufAny: return 351
+    case .googleProtobufApi: return 352
+    case .googleProtobufBoolValue: return 353
+    case .googleProtobufBytesValue: return 354
+    case .googleProtobufDescriptorProto: return 355
+    case .googleProtobufDoubleValue: return 356
+    case .googleProtobufDuration: return 357
+    case .googleProtobufEdition: return 358
+    case .googleProtobufEmpty: return 359
+    case .googleProtobufEnum: return 360
+    case .googleProtobufEnumDescriptorProto: return 361
+    case .googleProtobufEnumOptions: return 362
+    case .googleProtobufEnumValue: return 363
+    case .googleProtobufEnumValueDescriptorProto: return 364
+    case .googleProtobufEnumValueOptions: return 365
+    case .googleProtobufExtensionRangeOptions: return 366
+    case .googleProtobufFeatureSet: return 367
+    case .googleProtobufFeatureSetDefaults: return 368
+    case .googleProtobufField: return 369
+    case .googleProtobufFieldDescriptorProto: return 370
+    case .googleProtobufFieldMask: return 371
+    case .googleProtobufFieldOptions: return 372
+    case .googleProtobufFileDescriptorProto: return 373
+    case .googleProtobufFileDescriptorSet: return 374
+    case .googleProtobufFileOptions: return 375
+    case .googleProtobufFloatValue: return 376
+    case .googleProtobufGeneratedCodeInfo: return 377
+    case .googleProtobufInt32Value: return 378
+    case .googleProtobufInt64Value: return 379
+    case .googleProtobufListValue: return 380
+    case .googleProtobufMessageOptions: return 381
+    case .googleProtobufMethod: return 382
+    case .googleProtobufMethodDescriptorProto: return 383
+    case .googleProtobufMethodOptions: return 384
+    case .googleProtobufMixin: return 385
+    case .googleProtobufNullValue: return 386
+    case .googleProtobufOneofDescriptorProto: return 387
+    case .googleProtobufOneofOptions: return 388
+    case .googleProtobufOption: return 389
+    case .googleProtobufServiceDescriptorProto: return 390
+    case .googleProtobufServiceOptions: return 391
+    case .googleProtobufSourceCodeInfo: return 392
+    case .googleProtobufSourceContext: return 393
+    case .googleProtobufStringValue: return 394
+    case .googleProtobufStruct: return 395
+    case .googleProtobufSyntax: return 396
+    case .googleProtobufTimestamp: return 397
+    case .googleProtobufType: return 398
+    case .googleProtobufUint32Value: return 399
+    case .googleProtobufUint64Value: return 400
+    case .googleProtobufUninterpretedOption: return 401
+    case .googleProtobufValue: return 402
+    case .goPackage: return 403
+    case .group: return 404
+    case .groupFieldNumberStack: return 405
+    case .groupSize: return 406
+    case .hadOneofValue: return 407
+    case .handleConflictingOneOf: return 408
+    case .hasAggregateValue: return 409
+    case .hasAllowAlias: return 410
+    case .hasBegin: return 411
+    case .hasCcEnableArenas: return 412
+    case .hasCcGenericServices: return 413
+    case .hasClientStreaming: return 414
+    case .hasCsharpNamespace: return 415
+    case .hasCtype: return 416
+    case .hasDebugRedact: return 417
+    case .hasDefaultValue: return 418
+    case .hasDeprecated: return 419
+    case .hasDeprecatedLegacyJsonFieldConflicts: return 420
+    case .hasDoubleValue: return 421
+    case .hasEdition: return 422
+    case .hasEnd: return 423
+    case .hasEnumType: return 424
+    case .hasExtendee: return 425
+    case .hasExtensionValue: return 426
+    case .hasFeatures: return 427
+    case .hasFieldPresence: return 428
+    case .hasFullName: return 429
+    case .hasGoPackage: return 430
+    case .hash: return 431
+    case .hashable: return 432
+    case .hasher: return 433
+    case .hashVisitor: return 434
+    case .hasIdempotencyLevel: return 435
+    case .hasIdentifierValue: return 436
+    case .hasInputType: return 437
+    case .hasIsExtension: return 438
+    case .hasJavaGenerateEqualsAndHash: return 439
+    case .hasJavaGenericServices: return 440
+    case .hasJavaMultipleFiles: return 441
+    case .hasJavaOuterClassname: return 442
+    case .hasJavaPackage: return 443
+    case .hasJavaStringCheckUtf8: return 444
+    case .hasJsonFormat: return 445
+    case .hasJsonName: return 446
+    case .hasJstype: return 447
+    case .hasLabel: return 448
+    case .hasLazy: return 449
+    case .hasLeadingComments: return 450
+    case .hasMapEntry: return 451
+    case .hasMaximumEdition: return 452
+    case .hasMessageEncoding: return 453
+    case .hasMessageSetWireFormat: return 454
+    case .hasMinimumEdition: return 455
+    case .hasName: return 456
+    case .hasNamePart: return 457
+    case .hasNegativeIntValue: return 458
+    case .hasNoStandardDescriptorAccessor: return 459
+    case .hasNumber: return 460
+    case .hasObjcClassPrefix: return 461
+    case .hasOneofIndex: return 462
+    case .hasOptimizeFor: return 463
+    case .hasOptions: return 464
+    case .hasOutputType: return 465
+    case .hasPackage: return 466
+    case .hasPacked: return 467
+    case .hasPhpClassPrefix: return 468
+    case .hasPhpGenericServices: return 469
+    case .hasPhpMetadataNamespace: return 470
+    case .hasPhpNamespace: return 471
+    case .hasPositiveIntValue: return 472
+    case .hasProto3Optional: return 473
+    case .hasPyGenericServices: return 474
+    case .hasRepeated: return 475
+    case .hasRepeatedFieldEncoding: return 476
+    case .hasReserved: return 477
+    case .hasRetention: return 478
+    case .hasRubyPackage: return 479
+    case .hasSemantic: return 480
+    case .hasServerStreaming: return 481
+    case .hasSourceCodeInfo: return 482
+    case .hasSourceContext: return 483
+    case .hasSourceFile: return 484
+    case .hasStart: return 485
+    case .hasStringValue: return 486
+    case .hasSwiftPrefix: return 487
+    case .hasSyntax: return 488
+    case .hasTrailingComments: return 489
+    case .hasType: return 490
+    case .hasTypeName: return 491
+    case .hasUnverifiedLazy: return 492
+    case .hasUtf8Validation: return 493
+    case .hasValue: return 494
+    case .hasVerification: return 495
+    case .hasWeak: return 496
+    case .hour: return 497
+    case .i: return 498
+    case .idempotencyLevel: return 499
     default: break
     }
     switch self {
-    case .init_: return 500
-    case .inout: return 501
-    case .inputType: return 502
-    case .insert: return 503
-    case .int: return 504
-    case .int32: return 505
-    case .int32Value: return 506
-    case .int64: return 507
-    case .int64Value: return 508
-    case .int8: return 509
-    case .integerLiteral: return 510
-    case .integerLiteralType: return 511
-    case .intern: return 512
-    case .internal: return 513
-    case .internalState: return 514
-    case .into: return 515
-    case .ints: return 516
-    case .isA: return 517
-    case .isEqual: return 518
-    case .isEqualTo: return 519
-    case .isExtension: return 520
-    case .isInitialized: return 521
-    case .isNegative: return 522
-    case .itemTagsEncodedSize: return 523
-    case .iterator: return 524
-    case .javaGenerateEqualsAndHash: return 525
-    case .javaGenericServices: return 526
-    case .javaMultipleFiles: return 527
-    case .javaOuterClassname: return 528
-    case .javaPackage: return 529
-    case .javaStringCheckUtf8: return 530
-    case .jsondecoder: return 531
-    case .jsondecodingError: return 532
-    case .jsondecodingOptions: return 533
-    case .jsonEncoder: return 534
-    case .jsonencodingError: return 535
-    case .jsonencodingOptions: return 536
-    case .jsonencodingVisitor: return 537
-    case .jsonFormat: return 538
-    case .jsonmapEncodingVisitor: return 539
-    case .jsonName: return 540
-    case .jsonPath: return 541
-    case .jsonPaths: return 542
-    case .jsonscanner: return 543
-    case .jsonString: return 544
-    case .jsonText: return 545
-    case .jsonUtf8Bytes: return 546
-    case .jsonUtf8Data: return 547
-    case .jstype: return 548
-    case .k: return 549
-    case .kChunkSize: return 550
-    case .key: return 551
-    case .keyField: return 552
-    case .keyFieldOpt: return 553
-    case .keyType: return 554
-    case .kind: return 555
-    case .l: return 556
-    case .label: return 557
-    case .lazy: return 558
-    case .leadingComments: return 559
-    case .leadingDetachedComments: return 560
-    case .length: return 561
-    case .lessThan: return 562
-    case .let: return 563
-    case .lhs: return 564
-    case .list: return 565
-    case .listOfMessages: return 566
-    case .listValue: return 567
-    case .littleEndian: return 568
-    case .littleEndianBytes: return 569
-    case .load: return 570
-    case .localHasher: return 571
-    case .location: return 572
-    case .m: return 573
-    case .major: return 574
-    case .makeAsyncIterator: return 575
-    case .makeIterator: return 576
-    case .mapEntry: return 577
-    case .mapKeyType: return 578
-    case .mapToMessages: return 579
-    case .mapValueType: return 580
-    case .mapVisitor: return 581
-    case .maximumEdition: return 582
-    case .mdayStart: return 583
-    case .merge: return 584
-    case .message: return 585
-    case .messageDepthLimit: return 586
-    case .messageEncoding: return 587
-    case .messageExtension: return 588
-    case .messageImplementationBase: return 589
-    case .messageOptions: return 590
-    case .messageSet: return 591
-    case .messageSetWireFormat: return 592
-    case .messageSize: return 593
-    case .messageType: return 594
-    case .method: return 595
-    case .methodDescriptorProto: return 596
-    case .methodOptions: return 597
-    case .methods: return 598
-    case .min: return 599
-    case .minimumEdition: return 600
-    case .minor: return 601
-    case .mixin: return 602
-    case .mixins: return 603
-    case .modifier: return 604
-    case .modify: return 605
-    case .month: return 606
-    case .msgExtension: return 607
-    case .mutating: return 608
-    case .n: return 609
-    case .name: return 610
-    case .nameDescription: return 611
-    case .nameMap: return 612
-    case .namePart: return 613
-    case .names: return 614
-    case .nanos: return 615
-    case .negativeIntValue: return 616
-    case .nestedType: return 617
-    case .newL: return 618
-    case .newList: return 619
-    case .newValue: return 620
-    case .next: return 621
-    case .nextByte: return 622
-    case .nextFieldNumber: return 623
-    case .nextVarInt: return 624
-    case .nil: return 625
-    case .nilLiteral: return 626
-    case .noStandardDescriptorAccessor: return 627
-    case .nullValue: return 628
-    case .number: return 629
-    case .numberValue: return 630
-    case .objcClassPrefix: return 631
-    case .of: return 632
-    case .oneofDecl: return 633
-    case .oneofDescriptorProto: return 634
-    case .oneofIndex: return 635
-    case .oneofOptions: return 636
-    case .oneofs: return 637
-    case .oneOfKind: return 638
-    case .optimizeFor: return 639
-    case .optimizeMode: return 640
-    case .option: return 641
-    case .optionalEnumExtensionField: return 642
-    case .optionalExtensionField: return 643
-    case .optionalGroupExtensionField: return 644
-    case .optionalMessageExtensionField: return 645
-    case .optionRetention: return 646
-    case .options: return 647
-    case .optionTargetType: return 648
-    case .other: return 649
-    case .others: return 650
-    case .out: return 651
-    case .outputType: return 652
-    case .p: return 653
-    case .package: return 654
-    case .packed: return 655
-    case .packedEnumExtensionField: return 656
-    case .packedExtensionField: return 657
-    case .padding: return 658
-    case .parent: return 659
-    case .parse: return 660
-    case .path: return 661
-    case .paths: return 662
-    case .payload: return 663
-    case .payloadSize: return 664
-    case .phpClassPrefix: return 665
-    case .phpGenericServices: return 666
-    case .phpMetadataNamespace: return 667
-    case .phpNamespace: return 668
-    case .pos: return 669
-    case .positiveIntValue: return 670
-    case .prefix: return 671
-    case .preserveProtoFieldNames: return 672
-    case .preTraverse: return 673
-    case .printUnknownFields: return 674
-    case .proto2: return 675
-    case .proto3DefaultValue: return 676
-    case .proto3Optional: return 677
-    case .protobufApiversionCheck: return 678
-    case .protobufApiversion3: return 679
-    case .protobufBool: return 680
-    case .protobufBytes: return 681
-    case .protobufDouble: return 682
-    case .protobufEnumMap: return 683
-    case .protobufExtension: return 684
-    case .protobufFixed32: return 685
-    case .protobufFixed64: return 686
-    case .protobufFloat: return 687
-    case .protobufInt32: return 688
-    case .protobufInt64: return 689
-    case .protobufMap: return 690
-    case .protobufMessageMap: return 691
-    case .protobufSfixed32: return 692
-    case .protobufSfixed64: return 693
-    case .protobufSint32: return 694
-    case .protobufSint64: return 695
-    case .protobufString: return 696
-    case .protobufUint32: return 697
-    case .protobufUint64: return 698
-    case .protobufExtensionFieldValues: return 699
-    case .protobufFieldNumber: return 700
-    case .protobufGeneratedIsEqualTo: return 701
-    case .protobufNameMap: return 702
-    case .protobufNewField: return 703
-    case .protobufPackage: return 704
-    case .protocol: return 705
-    case .protoFieldName: return 706
-    case .protoMessageName: return 707
-    case .protoNameProviding: return 708
-    case .protoPaths: return 709
-    case .public: return 710
-    case .publicDependency: return 711
-    case .putBoolValue: return 712
-    case .putBytesValue: return 713
-    case .putDoubleValue: return 714
-    case .putEnumValue: return 715
-    case .putFixedUint32: return 716
-    case .putFixedUint64: return 717
-    case .putFloatValue: return 718
-    case .putInt64: return 719
-    case .putStringValue: return 720
-    case .putUint64: return 721
-    case .putUint64Hex: return 722
-    case .putVarInt: return 723
-    case .putZigZagVarInt: return 724
-    case .pyGenericServices: return 725
-    case .r: return 726
-    case .rawChars: return 727
-    case .rawRepresentable: return 728
-    case .rawValue_: return 729
-    case .read4HexDigits: return 730
-    case .readBytes: return 731
-    case .register: return 732
-    case .repeated: return 733
-    case .repeatedEnumExtensionField: return 734
-    case .repeatedExtensionField: return 735
-    case .repeatedFieldEncoding: return 736
-    case .repeatedGroupExtensionField: return 737
-    case .repeatedMessageExtensionField: return 738
-    case .repeating: return 739
-    case .requestStreaming: return 740
-    case .requestTypeURL: return 741
-    case .requiredSize: return 742
-    case .responseStreaming: return 743
-    case .responseTypeURL: return 744
-    case .result: return 745
-    case .retention: return 746
-    case .rethrows: return 747
-    case .return: return 748
-    case .returnType: return 749
-    case .revision: return 750
-    case .rhs: return 751
-    case .root: return 752
-    case .rubyPackage: return 753
-    case .s: return 754
-    case .sawBackslash: return 755
-    case .sawSection4Characters: return 756
-    case .sawSection5Characters: return 757
-    case .scanner: return 758
-    case .seconds: return 759
-    case .self_: return 760
-    case .semantic: return 761
-    case .sendable: return 762
-    case .separator: return 763
-    case .serialize: return 764
-    case .serializedBytes: return 765
-    case .serializedData: return 766
-    case .serializedSize: return 767
-    case .serverStreaming: return 768
-    case .service: return 769
-    case .serviceDescriptorProto: return 770
-    case .serviceOptions: return 771
-    case .set: return 772
-    case .setExtensionValue: return 773
-    case .shift: return 774
-    case .simpleExtensionMap: return 775
-    case .size: return 776
-    case .sizer: return 777
-    case .source: return 778
-    case .sourceCodeInfo: return 779
-    case .sourceContext: return 780
-    case .sourceEncoding: return 781
-    case .sourceFile: return 782
-    case .span: return 783
-    case .split: return 784
-    case .start: return 785
-    case .startArray: return 786
-    case .startArrayObject: return 787
-    case .startField: return 788
-    case .startIndex: return 789
-    case .startMessageField: return 790
-    case .startObject: return 791
-    case .startRegularField: return 792
-    case .state: return 793
-    case .static: return 794
-    case .staticString: return 795
-    case .storage: return 796
-    case .string: return 797
-    case .stringLiteral: return 798
-    case .stringLiteralType: return 799
-    case .stringResult: return 800
-    case .stringValue: return 801
-    case .struct: return 802
-    case .structValue: return 803
-    case .subDecoder: return 804
-    case .subscript: return 805
-    case .subVisitor: return 806
-    case .swift: return 807
-    case .swiftPrefix: return 808
-    case .swiftProtobufContiguousBytes: return 809
-    case .syntax: return 810
-    case .t: return 811
-    case .tag: return 812
-    case .targets: return 813
-    case .terminator: return 814
-    case .testDecoder: return 815
-    case .text: return 816
-    case .textDecoder: return 817
-    case .textFormatDecoder: return 818
-    case .textFormatDecodingError: return 819
-    case .textFormatDecodingOptions: return 820
-    case .textFormatEncodingOptions: return 821
-    case .textFormatEncodingVisitor: return 822
-    case .textFormatString: return 823
-    case .throwOrIgnore: return 824
-    case .throws: return 825
-    case .timeInterval: return 826
-    case .timeIntervalSince1970: return 827
-    case .timeIntervalSinceReferenceDate: return 828
-    case .timestamp: return 829
-    case .total: return 830
-    case .totalArrayDepth: return 831
-    case .totalSize: return 832
-    case .trailingComments: return 833
-    case .traverse: return 834
-    case .true: return 835
-    case .try: return 836
-    case .type: return 837
-    case .typealias: return 838
-    case .typeEnum: return 839
-    case .typeName: return 840
-    case .typePrefix: return 841
-    case .typeStart: return 842
-    case .typeUnknown: return 843
-    case .typeURL: return 844
-    case .uint32: return 845
-    case .uint32Value: return 846
-    case .uint64: return 847
-    case .uint64Value: return 848
-    case .uint8: return 849
-    case .unchecked: return 850
-    case .unicodeScalarLiteral: return 851
-    case .unicodeScalarLiteralType: return 852
-    case .unicodeScalars: return 853
-    case .unicodeScalarView: return 854
-    case .uninterpretedOption: return 855
-    case .union: return 856
-    case .uniqueStorage: return 857
-    case .unknown: return 858
-    case .unknownFields: return 859
-    case .unknownStorage: return 860
-    case .unpackTo: return 861
-    case .unsafeBufferPointer: return 862
-    case .unsafeMutablePointer: return 863
-    case .unsafeMutableRawBufferPointer: return 864
-    case .unsafeRawBufferPointer: return 865
-    case .unsafeRawPointer: return 866
-    case .unverifiedLazy: return 867
-    case .updatedOptions: return 868
-    case .url: return 869
-    case .useDeterministicOrdering: return 870
-    case .utf8: return 871
-    case .utf8Ptr: return 872
-    case .utf8ToDouble: return 873
-    case .utf8Validation: return 874
-    case .utf8View: return 875
-    case .v: return 876
-    case .value: return 877
-    case .valueField: return 878
-    case .values: return 879
-    case .valueType: return 880
-    case .var: return 881
-    case .verification: return 882
-    case .verificationState: return 883
-    case .version: return 884
-    case .versionString: return 885
-    case .visitExtensionFields: return 886
-    case .visitExtensionFieldsAsMessageSet: return 887
-    case .visitMapField: return 888
-    case .visitor: return 889
-    case .visitPacked: return 890
-    case .visitPackedBoolField: return 891
-    case .visitPackedDoubleField: return 892
-    case .visitPackedEnumField: return 893
-    case .visitPackedFixed32Field: return 894
-    case .visitPackedFixed64Field: return 895
-    case .visitPackedFloatField: return 896
-    case .visitPackedInt32Field: return 897
-    case .visitPackedInt64Field: return 898
-    case .visitPackedSfixed32Field: return 899
-    case .visitPackedSfixed64Field: return 900
-    case .visitPackedSint32Field: return 901
-    case .visitPackedSint64Field: return 902
-    case .visitPackedUint32Field: return 903
-    case .visitPackedUint64Field: return 904
-    case .visitRepeated: return 905
-    case .visitRepeatedBoolField: return 906
-    case .visitRepeatedBytesField: return 907
-    case .visitRepeatedDoubleField: return 908
-    case .visitRepeatedEnumField: return 909
-    case .visitRepeatedFixed32Field: return 910
-    case .visitRepeatedFixed64Field: return 911
-    case .visitRepeatedFloatField: return 912
-    case .visitRepeatedGroupField: return 913
-    case .visitRepeatedInt32Field: return 914
-    case .visitRepeatedInt64Field: return 915
-    case .visitRepeatedMessageField: return 916
-    case .visitRepeatedSfixed32Field: return 917
-    case .visitRepeatedSfixed64Field: return 918
-    case .visitRepeatedSint32Field: return 919
-    case .visitRepeatedSint64Field: return 920
-    case .visitRepeatedStringField: return 921
-    case .visitRepeatedUint32Field: return 922
-    case .visitRepeatedUint64Field: return 923
-    case .visitSingular: return 924
-    case .visitSingularBoolField: return 925
-    case .visitSingularBytesField: return 926
-    case .visitSingularDoubleField: return 927
-    case .visitSingularEnumField: return 928
-    case .visitSingularFixed32Field: return 929
-    case .visitSingularFixed64Field: return 930
-    case .visitSingularFloatField: return 931
-    case .visitSingularGroupField: return 932
-    case .visitSingularInt32Field: return 933
-    case .visitSingularInt64Field: return 934
-    case .visitSingularMessageField: return 935
-    case .visitSingularSfixed32Field: return 936
-    case .visitSingularSfixed64Field: return 937
-    case .visitSingularSint32Field: return 938
-    case .visitSingularSint64Field: return 939
-    case .visitSingularStringField: return 940
-    case .visitSingularUint32Field: return 941
-    case .visitSingularUint64Field: return 942
-    case .visitUnknown: return 943
-    case .wasDecoded: return 944
-    case .weak: return 945
-    case .weakDependency: return 946
-    case .where: return 947
-    case .wireFormat: return 948
-    case .with: return 949
-    case .withUnsafeBytes: return 950
-    case .withUnsafeMutableBytes: return 951
-    case .work: return 952
-    case .wrapped: return 953
-    case .wrappedType: return 954
-    case .wrappedValue: return 955
-    case .written: return 956
-    case .yday: return 957
+    case .identifierValue: return 500
+    case .if: return 501
+    case .ignoreUnknownFields: return 502
+    case .index: return 503
+    case .init_: return 504
+    case .inout: return 505
+    case .inputType: return 506
+    case .insert: return 507
+    case .int: return 508
+    case .int32: return 509
+    case .int32Value: return 510
+    case .int64: return 511
+    case .int64Value: return 512
+    case .int8: return 513
+    case .integerLiteral: return 514
+    case .integerLiteralType: return 515
+    case .intern: return 516
+    case .internal: return 517
+    case .internalState: return 518
+    case .into: return 519
+    case .ints: return 520
+    case .isA: return 521
+    case .isEqual: return 522
+    case .isEqualTo: return 523
+    case .isExtension: return 524
+    case .isInitialized: return 525
+    case .isNegative: return 526
+    case .isUnset: return 527
+    case .itemTagsEncodedSize: return 528
+    case .iterator: return 529
+    case .javaGenerateEqualsAndHash: return 530
+    case .javaGenericServices: return 531
+    case .javaMultipleFiles: return 532
+    case .javaOuterClassname: return 533
+    case .javaPackage: return 534
+    case .javaStringCheckUtf8: return 535
+    case .jsondecoder: return 536
+    case .jsondecodingError: return 537
+    case .jsondecodingOptions: return 538
+    case .jsonEncoder: return 539
+    case .jsonencodingError: return 540
+    case .jsonencodingOptions: return 541
+    case .jsonencodingVisitor: return 542
+    case .jsonFormat: return 543
+    case .jsonmapEncodingVisitor: return 544
+    case .jsonName: return 545
+    case .jsonPath: return 546
+    case .jsonPaths: return 547
+    case .jsonscanner: return 548
+    case .jsonString: return 549
+    case .jsonText: return 550
+    case .jsonUtf8Bytes: return 551
+    case .jsonUtf8Data: return 552
+    case .jstype: return 553
+    case .k: return 554
+    case .kChunkSize: return 555
+    case .key: return 556
+    case .keyField: return 557
+    case .keyFieldOpt: return 558
+    case .keyType: return 559
+    case .kind: return 560
+    case .l: return 561
+    case .label: return 562
+    case .lazy: return 563
+    case .leadingComments: return 564
+    case .leadingDetachedComments: return 565
+    case .length: return 566
+    case .lessThan: return 567
+    case .let: return 568
+    case .lhs: return 569
+    case .list: return 570
+    case .listOfMessages: return 571
+    case .listValue: return 572
+    case .littleEndian: return 573
+    case .littleEndianBytes: return 574
+    case .load: return 575
+    case .localHasher: return 576
+    case .location: return 577
+    case .m: return 578
+    case .major: return 579
+    case .makeAsyncIterator: return 580
+    case .makeIterator: return 581
+    case .map: return 582
+    case .mapEntry: return 583
+    case .mapKeyType: return 584
+    case .mapToMessages: return 585
+    case .mapValueType: return 586
+    case .mapVisitor: return 587
+    case .maximumEdition: return 588
+    case .mdayStart: return 589
+    case .merge: return 590
+    case .message: return 591
+    case .messageDepthLimit: return 592
+    case .messageEncoding: return 593
+    case .messageExtension: return 594
+    case .messageImplementationBase: return 595
+    case .messageOptions: return 596
+    case .messageSet: return 597
+    case .messageSetWireFormat: return 598
+    case .messageSize: return 599
+    case .messageType: return 600
+    case .method: return 601
+    case .methodDescriptorProto: return 602
+    case .methodOptions: return 603
+    case .methods: return 604
+    case .min: return 605
+    case .minimumEdition: return 606
+    case .minor: return 607
+    case .mixin: return 608
+    case .mixins: return 609
+    case .modifier: return 610
+    case .modify: return 611
+    case .month: return 612
+    case .msgExtension: return 613
+    case .mutating: return 614
+    case .n: return 615
+    case .name: return 616
+    case .nameDescription: return 617
+    case .nameMap: return 618
+    case .namePart: return 619
+    case .names: return 620
+    case .nanos: return 621
+    case .negativeIntValue: return 622
+    case .nestedType: return 623
+    case .newL: return 624
+    case .newList: return 625
+    case .newValue: return 626
+    case .next: return 627
+    case .nextByte: return 628
+    case .nextFieldNumber: return 629
+    case .nextVarInt: return 630
+    case .nil: return 631
+    case .nilLiteral: return 632
+    case .noStandardDescriptorAccessor: return 633
+    case .nullValue: return 634
+    case .number: return 635
+    case .numberValue: return 636
+    case .objcClassPrefix: return 637
+    case .of: return 638
+    case .oneOf: return 639
+    case .oneofDecl: return 640
+    case .oneofDescriptorProto: return 641
+    case .oneofIndex: return 642
+    case .oneofOptions: return 643
+    case .oneofs: return 644
+    case .oneOfKind: return 645
+    case .optimizeFor: return 646
+    case .optimizeMode: return 647
+    case .option: return 648
+    case .optionalEnumExtensionField: return 649
+    case .optionalExtensionField: return 650
+    case .optionalGroupExtensionField: return 651
+    case .optionalMessageExtensionField: return 652
+    case .optionRetention: return 653
+    case .options: return 654
+    case .optionTargetType: return 655
+    case .other: return 656
+    case .others: return 657
+    case .out: return 658
+    case .outputType: return 659
+    case .p: return 660
+    case .package: return 661
+    case .packed: return 662
+    case .packedBool: return 663
+    case .packedDouble: return 664
+    case .packedEnum: return 665
+    case .packedEnumExtensionField: return 666
+    case .packedExtensionField: return 667
+    case .packedFixed32: return 668
+    case .packedFixed64: return 669
+    case .packedFloat: return 670
+    case .packedInt32: return 671
+    case .packedInt64: return 672
+    case .packedSfixed32: return 673
+    case .packedSfixed64: return 674
+    case .packedSint32: return 675
+    case .packedSint64: return 676
+    case .packedUint32: return 677
+    case .packedUint64: return 678
+    case .padding: return 679
+    case .parent: return 680
+    case .parse: return 681
+    case .path: return 682
+    case .paths: return 683
+    case .payload: return 684
+    case .payloadSize: return 685
+    case .phpClassPrefix: return 686
+    case .phpGenericServices: return 687
+    case .phpMetadataNamespace: return 688
+    case .phpNamespace: return 689
+    case .pos: return 690
+    case .positiveIntValue: return 691
+    case .prefix: return 692
+    case .preserveProtoFieldNames: return 693
+    case .preTraverse: return 694
+    case .printUnknownFields: return 695
+    case .proto2: return 696
+    case .proto3DefaultValue: return 697
+    case .proto3Optional: return 698
+    case .protobufApiversionCheck: return 699
+    case .protobufApiversion3: return 700
+    case .protobufBool: return 701
+    case .protobufBytes: return 702
+    case .protobufDouble: return 703
+    case .protobufEnumMap: return 704
+    case .protobufExtension: return 705
+    case .protobufFixed32: return 706
+    case .protobufFixed64: return 707
+    case .protobufFloat: return 708
+    case .protobufInt32: return 709
+    case .protobufInt64: return 710
+    case .protobufMap: return 711
+    case .protobufMessageMap: return 712
+    case .protobufSfixed32: return 713
+    case .protobufSfixed64: return 714
+    case .protobufSint32: return 715
+    case .protobufSint64: return 716
+    case .protobufString: return 717
+    case .protobufUint32: return 718
+    case .protobufUint64: return 719
+    case .protobufExtensionFieldValues: return 720
+    case .protobufFieldNumber: return 721
+    case .protobufGeneratedIsEqualTo: return 722
+    case .protobufNameMap: return 723
+    case .protobufNewField: return 724
+    case .protobufPackage: return 725
+    case .protocol: return 726
+    case .protoFieldName: return 727
+    case .protoMessageName: return 728
+    case .protoNameProviding: return 729
+    case .protoPaths: return 730
+    case .public: return 731
+    case .publicDependency: return 732
+    case .putBoolValue: return 733
+    case .putBytesValue: return 734
+    case .putDoubleValue: return 735
+    case .putEnumValue: return 736
+    case .putFixedUint32: return 737
+    case .putFixedUint64: return 738
+    case .putFloatValue: return 739
+    case .putInt64: return 740
+    case .putStringValue: return 741
+    case .putUint64: return 742
+    case .putUint64Hex: return 743
+    case .putVarInt: return 744
+    case .putZigZagVarInt: return 745
+    case .pyGenericServices: return 746
+    case .r: return 747
+    case .rawChars: return 748
+    case .rawRepresentable: return 749
+    case .rawValue_: return 750
+    case .read4HexDigits: return 751
+    case .readBytes: return 752
+    case .register: return 753
+    case .repeated: return 754
+    case .repeatedBool: return 755
+    case .repeatedBytes: return 756
+    case .repeatedDouble: return 757
+    case .repeatedEnum: return 758
+    case .repeatedEnumExtensionField: return 759
+    case .repeatedExtensionField: return 760
+    case .repeatedFieldEncoding: return 761
+    case .repeatedFixed32: return 762
+    case .repeatedFixed64: return 763
+    case .repeatedFloat: return 764
+    case .repeatedGroup: return 765
+    case .repeatedGroupExtensionField: return 766
+    case .repeatedInt32: return 767
+    case .repeatedInt64: return 768
+    case .repeatedMessage: return 769
+    case .repeatedMessageExtensionField: return 770
+    case .repeatedSfixed32: return 771
+    case .repeatedSfixed64: return 772
+    case .repeatedSint32: return 773
+    case .repeatedSint64: return 774
+    case .repeatedString: return 775
+    case .repeatedUint32: return 776
+    case .repeatedUint64: return 777
+    case .repeating: return 778
+    case .requestStreaming: return 779
+    case .requestTypeURL: return 780
+    case .requiredSize: return 781
+    case .responseStreaming: return 782
+    case .responseTypeURL: return 783
+    case .result: return 784
+    case .retention: return 785
+    case .rethrows: return 786
+    case .return: return 787
+    case .returnType: return 788
+    case .revision: return 789
+    case .rhs: return 790
+    case .root: return 791
+    case .rubyPackage: return 792
+    case .s: return 793
+    case .sawBackslash: return 794
+    case .sawSection4Characters: return 795
+    case .sawSection5Characters: return 796
+    case .scanner: return 797
+    case .seconds: return 798
+    case .self_: return 799
+    case .semantic: return 800
+    case .sendable: return 801
+    case .separator: return 802
+    case .serialize: return 803
+    case .serializedBytes: return 804
+    case .serializedData: return 805
+    case .serializedSize: return 806
+    case .serverStreaming: return 807
+    case .service: return 808
+    case .serviceDescriptorProto: return 809
+    case .serviceOptions: return 810
+    case .set: return 811
+    case .setExtensionValue: return 812
+    case .shift: return 813
+    case .simpleExtensionMap: return 814
+    case .singularBool: return 815
+    case .singularBytes: return 816
+    case .singularDouble: return 817
+    case .singularEnum: return 818
+    case .singularFixed32: return 819
+    case .singularFixed64: return 820
+    case .singularFloat: return 821
+    case .singularGroup: return 822
+    case .singularInt32: return 823
+    case .singularInt64: return 824
+    case .singularMessage: return 825
+    case .singularSfixed32: return 826
+    case .singularSfixed64: return 827
+    case .singularSint32: return 828
+    case .singularSint64: return 829
+    case .singularString: return 830
+    case .singularUint32: return 831
+    case .singularUint64: return 832
+    case .size: return 833
+    case .sizer: return 834
+    case .source: return 835
+    case .sourceCodeInfo: return 836
+    case .sourceContext: return 837
+    case .sourceEncoding: return 838
+    case .sourceFile: return 839
+    case .span: return 840
+    case .split: return 841
+    case .start: return 842
+    case .startArray: return 843
+    case .startArrayObject: return 844
+    case .startField: return 845
+    case .startIndex: return 846
+    case .startMessageField: return 847
+    case .startObject: return 848
+    case .startRegularField: return 849
+    case .state: return 850
+    case .static: return 851
+    case .staticString: return 852
+    case .storage: return 853
+    case .string: return 854
+    case .stringLiteral: return 855
+    case .stringLiteralType: return 856
+    case .stringResult: return 857
+    case .stringValue: return 858
+    case .struct: return 859
+    case .structValue: return 860
+    case .subDecoder: return 861
+    case .subscript: return 862
+    case .subVisitor: return 863
+    case .swift: return 864
+    case .swiftPrefix: return 865
+    case .swiftProtobufContiguousBytes: return 866
+    case .syntax: return 867
+    case .t: return 868
+    case .tag: return 869
+    case .targets: return 870
+    case .terminator: return 871
+    case .testDecoder: return 872
+    case .text: return 873
+    case .textDecoder: return 874
+    case .textFormatDecoder: return 875
+    case .textFormatDecodingError: return 876
+    case .textFormatDecodingOptions: return 877
+    case .textFormatEncodingOptions: return 878
+    case .textFormatEncodingVisitor: return 879
+    case .textFormatString: return 880
+    case .throwOrIgnore: return 881
+    case .throws: return 882
+    case .timeInterval: return 883
+    case .timeIntervalSince1970: return 884
+    case .timeIntervalSinceReferenceDate: return 885
+    case .timestamp: return 886
+    case .toConcrete: return 887
+    case .total: return 888
+    case .totalArrayDepth: return 889
+    case .totalSize: return 890
+    case .trailingComments: return 891
+    case .traverse: return 892
+    case .true: return 893
+    case .try: return 894
+    case .type: return 895
+    case .typealias: return 896
+    case .typeEnum: return 897
+    case .typeName: return 898
+    case .typePrefix: return 899
+    case .typeStart: return 900
+    case .typeUnknown: return 901
+    case .typeURL: return 902
+    case .uint32: return 903
+    case .uint32Value: return 904
+    case .uint64: return 905
+    case .uint64Value: return 906
+    case .uint8: return 907
+    case .unchecked: return 908
+    case .unicodeScalarLiteral: return 909
+    case .unicodeScalarLiteralType: return 910
+    case .unicodeScalars: return 911
+    case .unicodeScalarView: return 912
+    case .uninterpretedOption: return 913
+    case .union: return 914
+    case .uniqueStorage: return 915
+    case .unknown: return 916
+    case .unknownFields: return 917
+    case .unknownStorage: return 918
+    case .unpackTo: return 919
+    case .unsafeBufferPointer: return 920
+    case .unsafeMutablePointer: return 921
+    case .unsafeMutableRawBufferPointer: return 922
+    case .unsafeRawBufferPointer: return 923
+    case .unsafeRawPointer: return 924
+    case .unverifiedLazy: return 925
+    case .updatedOptions: return 926
+    case .url: return 927
+    case .useDeterministicOrdering: return 928
+    case .utf8: return 929
+    case .utf8Ptr: return 930
+    case .utf8ToDouble: return 931
+    case .utf8Validation: return 932
+    case .utf8View: return 933
+    case .v: return 934
+    case .value: return 935
+    case .valueField: return 936
+    case .values: return 937
+    case .valueType: return 938
+    case .var: return 939
+    case .verification: return 940
+    case .verificationState: return 941
+    case .version: return 942
+    case .versionString: return 943
+    case .visitExtensionFields: return 944
+    case .visitExtensionFieldsAsMessageSet: return 945
+    case .visitMapField: return 946
+    case .visitor: return 947
+    case .visitPacked: return 948
+    case .visitPackedBoolField: return 949
+    case .visitPackedDoubleField: return 950
+    case .visitPackedEnumField: return 951
+    case .visitPackedFixed32Field: return 952
+    case .visitPackedFixed64Field: return 953
+    case .visitPackedFloatField: return 954
+    case .visitPackedInt32Field: return 955
+    case .visitPackedInt64Field: return 956
+    case .visitPackedSfixed32Field: return 957
+    case .visitPackedSfixed64Field: return 958
+    case .visitPackedSint32Field: return 959
+    case .visitPackedSint64Field: return 960
+    case .visitPackedUint32Field: return 961
+    case .visitPackedUint64Field: return 962
+    case .visitRepeated: return 963
+    case .visitRepeatedBoolField: return 964
+    case .visitRepeatedBytesField: return 965
+    case .visitRepeatedDoubleField: return 966
+    case .visitRepeatedEnumField: return 967
+    case .visitRepeatedFixed32Field: return 968
+    case .visitRepeatedFixed64Field: return 969
+    case .visitRepeatedFloatField: return 970
+    case .visitRepeatedGroupField: return 971
+    case .visitRepeatedInt32Field: return 972
+    case .visitRepeatedInt64Field: return 973
+    case .visitRepeatedMessageField: return 974
+    case .visitRepeatedSfixed32Field: return 975
+    case .visitRepeatedSfixed64Field: return 976
+    case .visitRepeatedSint32Field: return 977
+    case .visitRepeatedSint64Field: return 978
+    case .visitRepeatedStringField: return 979
+    case .visitRepeatedUint32Field: return 980
+    case .visitRepeatedUint64Field: return 981
+    case .visitSingular: return 982
+    case .visitSingularBoolField: return 983
+    case .visitSingularBytesField: return 984
+    case .visitSingularDoubleField: return 985
+    case .visitSingularEnumField: return 986
+    case .visitSingularFixed32Field: return 987
+    case .visitSingularFixed64Field: return 988
+    case .visitSingularFloatField: return 989
+    case .visitSingularGroupField: return 990
+    case .visitSingularInt32Field: return 991
+    case .visitSingularInt64Field: return 992
+    case .visitSingularMessageField: return 993
+    case .visitSingularSfixed32Field: return 994
+    case .visitSingularSfixed64Field: return 995
+    case .visitSingularSint32Field: return 996
+    case .visitSingularSint64Field: return 997
+    case .visitSingularStringField: return 998
+    case .visitSingularUint32Field: return 999
+    default: break
+    }
+    switch self {
+    case .visitSingularUint64Field: return 1000
+    case .visitUnknown: return 1001
+    case .wasDecoded: return 1002
+    case .weak: return 1003
+    case .weakDependency: return 1004
+    case .where: return 1005
+    case .wireFormat: return 1006
+    case .with: return 1007
+    case .withUnsafeBytes: return 1008
+    case .withUnsafeMutableBytes: return 1009
+    case .work: return 1010
+    case .wrapped: return 1011
+    case .wrappedType: return 1012
+    case .wrappedValue: return 1013
+    case .written: return 1014
+    case .yday: return 1015
     case .UNRECOGNIZED(let i): return i
     default: break
     }
@@ -3206,6 +3383,7 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     .enumValueOptions,
     .equatable,
     .error,
+    .escaping,
     .expressibleByArrayLiteral,
     .expressibleByDictionaryLiteral,
     .ext,
@@ -3217,6 +3395,8 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     .extension,
     .extensionField,
     .extensionFieldNumber,
+    .extensionFields,
+    .extensionFieldsAsMessageSet,
     .extensionFieldValueSet,
     .extensionMap,
     .extensionRange,
@@ -3274,6 +3454,7 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     .generatedCodeInfo,
     .get,
     .getExtensionValue,
+    .getValue,
     .googleapis,
     .googleProtobufAny,
     .googleProtobufApi,
@@ -3451,6 +3632,7 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     .isExtension,
     .isInitialized,
     .isNegative,
+    .isUnset,
     .itemTagsEncodedSize,
     .iterator,
     .javaGenerateEqualsAndHash,
@@ -3505,6 +3687,7 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     .major,
     .makeAsyncIterator,
     .makeIterator,
+    .map,
     .mapEntry,
     .mapKeyType,
     .mapToMessages,
@@ -3561,6 +3744,7 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     .numberValue,
     .objcClassPrefix,
     .of,
+    .oneOf,
     .oneofDecl,
     .oneofDescriptorProto,
     .oneofIndex,
@@ -3584,8 +3768,22 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     .p,
     .package,
     .packed,
+    .packedBool,
+    .packedDouble,
+    .packedEnum,
     .packedEnumExtensionField,
     .packedExtensionField,
+    .packedFixed32,
+    .packedFixed64,
+    .packedFloat,
+    .packedInt32,
+    .packedInt64,
+    .packedSfixed32,
+    .packedSfixed64,
+    .packedSint32,
+    .packedSint64,
+    .packedUint32,
+    .packedUint64,
     .padding,
     .parent,
     .parse,
@@ -3662,11 +3860,29 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     .readBytes,
     .register,
     .repeated,
+    .repeatedBool,
+    .repeatedBytes,
+    .repeatedDouble,
+    .repeatedEnum,
     .repeatedEnumExtensionField,
     .repeatedExtensionField,
     .repeatedFieldEncoding,
+    .repeatedFixed32,
+    .repeatedFixed64,
+    .repeatedFloat,
+    .repeatedGroup,
     .repeatedGroupExtensionField,
+    .repeatedInt32,
+    .repeatedInt64,
+    .repeatedMessage,
     .repeatedMessageExtensionField,
+    .repeatedSfixed32,
+    .repeatedSfixed64,
+    .repeatedSint32,
+    .repeatedSint64,
+    .repeatedString,
+    .repeatedUint32,
+    .repeatedUint64,
     .repeating,
     .requestStreaming,
     .requestTypeURL,
@@ -3704,6 +3920,24 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     .setExtensionValue,
     .shift,
     .simpleExtensionMap,
+    .singularBool,
+    .singularBytes,
+    .singularDouble,
+    .singularEnum,
+    .singularFixed32,
+    .singularFixed64,
+    .singularFloat,
+    .singularGroup,
+    .singularInt32,
+    .singularInt64,
+    .singularMessage,
+    .singularSfixed32,
+    .singularSfixed64,
+    .singularSint32,
+    .singularSint64,
+    .singularString,
+    .singularUint32,
+    .singularUint64,
     .size,
     .sizer,
     .source,
@@ -3758,6 +3992,7 @@ enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum
     .timeIntervalSince1970,
     .timeIntervalSinceReferenceDate,
     .timestamp,
+    .toConcrete,
     .total,
     .totalArrayDepth,
     .totalSize,
@@ -4172,685 +4407,743 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.
     275: .same(proto: "EnumValueOptions"),
     276: .same(proto: "Equatable"),
     277: .same(proto: "Error"),
-    278: .same(proto: "ExpressibleByArrayLiteral"),
-    279: .same(proto: "ExpressibleByDictionaryLiteral"),
-    280: .same(proto: "ext"),
-    281: .same(proto: "extDecoder"),
-    282: .same(proto: "extendedGraphemeClusterLiteral"),
-    283: .same(proto: "ExtendedGraphemeClusterLiteralType"),
-    284: .same(proto: "extendee"),
-    285: .same(proto: "ExtensibleMessage"),
-    286: .same(proto: "extension"),
-    287: .same(proto: "ExtensionField"),
-    288: .same(proto: "extensionFieldNumber"),
-    289: .same(proto: "ExtensionFieldValueSet"),
-    290: .same(proto: "ExtensionMap"),
-    291: .same(proto: "extensionRange"),
-    292: .same(proto: "ExtensionRangeOptions"),
-    293: .same(proto: "extensions"),
-    294: .same(proto: "extras"),
-    295: .same(proto: "F"),
-    296: .same(proto: "false"),
-    297: .same(proto: "features"),
-    298: .same(proto: "FeatureSet"),
-    299: .same(proto: "FeatureSetDefaults"),
-    300: .same(proto: "FeatureSetEditionDefault"),
-    301: .same(proto: "field"),
-    302: .same(proto: "fieldData"),
-    303: .same(proto: "FieldDescriptorProto"),
-    304: .same(proto: "FieldMask"),
-    305: .same(proto: "fieldName"),
-    306: .same(proto: "fieldNameCount"),
-    307: .same(proto: "fieldNum"),
-    308: .same(proto: "fieldNumber"),
-    309: .same(proto: "fieldNumberForProto"),
-    310: .same(proto: "FieldOptions"),
-    311: .same(proto: "fieldPresence"),
-    312: .same(proto: "fields"),
-    313: .same(proto: "fieldSize"),
-    314: .same(proto: "FieldTag"),
-    315: .same(proto: "fieldType"),
-    316: .same(proto: "file"),
-    317: .same(proto: "FileDescriptorProto"),
-    318: .same(proto: "FileDescriptorSet"),
-    319: .same(proto: "fileName"),
-    320: .same(proto: "FileOptions"),
-    321: .same(proto: "filter"),
-    322: .same(proto: "final"),
-    323: .same(proto: "first"),
-    324: .same(proto: "firstItem"),
-    325: .same(proto: "Float"),
-    326: .same(proto: "floatLiteral"),
-    327: .same(proto: "FloatLiteralType"),
-    328: .same(proto: "FloatValue"),
-    329: .same(proto: "forMessageName"),
-    330: .same(proto: "formUnion"),
-    331: .same(proto: "forReadingFrom"),
-    332: .same(proto: "forTypeURL"),
-    333: .same(proto: "ForwardParser"),
-    334: .same(proto: "forWritingInto"),
-    335: .same(proto: "from"),
-    336: .same(proto: "fromAscii2"),
-    337: .same(proto: "fromAscii4"),
-    338: .same(proto: "fromByteOffset"),
-    339: .same(proto: "fromHexDigit"),
-    340: .same(proto: "fullName"),
-    341: .same(proto: "func"),
-    342: .same(proto: "G"),
-    343: .same(proto: "GeneratedCodeInfo"),
-    344: .same(proto: "get"),
-    345: .same(proto: "getExtensionValue"),
-    346: .same(proto: "googleapis"),
-    347: .same(proto: "Google_Protobuf_Any"),
-    348: .same(proto: "Google_Protobuf_Api"),
-    349: .same(proto: "Google_Protobuf_BoolValue"),
-    350: .same(proto: "Google_Protobuf_BytesValue"),
-    351: .same(proto: "Google_Protobuf_DescriptorProto"),
-    352: .same(proto: "Google_Protobuf_DoubleValue"),
-    353: .same(proto: "Google_Protobuf_Duration"),
-    354: .same(proto: "Google_Protobuf_Edition"),
-    355: .same(proto: "Google_Protobuf_Empty"),
-    356: .same(proto: "Google_Protobuf_Enum"),
-    357: .same(proto: "Google_Protobuf_EnumDescriptorProto"),
-    358: .same(proto: "Google_Protobuf_EnumOptions"),
-    359: .same(proto: "Google_Protobuf_EnumValue"),
-    360: .same(proto: "Google_Protobuf_EnumValueDescriptorProto"),
-    361: .same(proto: "Google_Protobuf_EnumValueOptions"),
-    362: .same(proto: "Google_Protobuf_ExtensionRangeOptions"),
-    363: .same(proto: "Google_Protobuf_FeatureSet"),
-    364: .same(proto: "Google_Protobuf_FeatureSetDefaults"),
-    365: .same(proto: "Google_Protobuf_Field"),
-    366: .same(proto: "Google_Protobuf_FieldDescriptorProto"),
-    367: .same(proto: "Google_Protobuf_FieldMask"),
-    368: .same(proto: "Google_Protobuf_FieldOptions"),
-    369: .same(proto: "Google_Protobuf_FileDescriptorProto"),
-    370: .same(proto: "Google_Protobuf_FileDescriptorSet"),
-    371: .same(proto: "Google_Protobuf_FileOptions"),
-    372: .same(proto: "Google_Protobuf_FloatValue"),
-    373: .same(proto: "Google_Protobuf_GeneratedCodeInfo"),
-    374: .same(proto: "Google_Protobuf_Int32Value"),
-    375: .same(proto: "Google_Protobuf_Int64Value"),
-    376: .same(proto: "Google_Protobuf_ListValue"),
-    377: .same(proto: "Google_Protobuf_MessageOptions"),
-    378: .same(proto: "Google_Protobuf_Method"),
-    379: .same(proto: "Google_Protobuf_MethodDescriptorProto"),
-    380: .same(proto: "Google_Protobuf_MethodOptions"),
-    381: .same(proto: "Google_Protobuf_Mixin"),
-    382: .same(proto: "Google_Protobuf_NullValue"),
-    383: .same(proto: "Google_Protobuf_OneofDescriptorProto"),
-    384: .same(proto: "Google_Protobuf_OneofOptions"),
-    385: .same(proto: "Google_Protobuf_Option"),
-    386: .same(proto: "Google_Protobuf_ServiceDescriptorProto"),
-    387: .same(proto: "Google_Protobuf_ServiceOptions"),
-    388: .same(proto: "Google_Protobuf_SourceCodeInfo"),
-    389: .same(proto: "Google_Protobuf_SourceContext"),
-    390: .same(proto: "Google_Protobuf_StringValue"),
-    391: .same(proto: "Google_Protobuf_Struct"),
-    392: .same(proto: "Google_Protobuf_Syntax"),
-    393: .same(proto: "Google_Protobuf_Timestamp"),
-    394: .same(proto: "Google_Protobuf_Type"),
-    395: .same(proto: "Google_Protobuf_UInt32Value"),
-    396: .same(proto: "Google_Protobuf_UInt64Value"),
-    397: .same(proto: "Google_Protobuf_UninterpretedOption"),
-    398: .same(proto: "Google_Protobuf_Value"),
-    399: .same(proto: "goPackage"),
-    400: .same(proto: "group"),
-    401: .same(proto: "groupFieldNumberStack"),
-    402: .same(proto: "groupSize"),
-    403: .same(proto: "hadOneofValue"),
-    404: .same(proto: "handleConflictingOneOf"),
-    405: .same(proto: "hasAggregateValue"),
-    406: .same(proto: "hasAllowAlias"),
-    407: .same(proto: "hasBegin"),
-    408: .same(proto: "hasCcEnableArenas"),
-    409: .same(proto: "hasCcGenericServices"),
-    410: .same(proto: "hasClientStreaming"),
-    411: .same(proto: "hasCsharpNamespace"),
-    412: .same(proto: "hasCtype"),
-    413: .same(proto: "hasDebugRedact"),
-    414: .same(proto: "hasDefaultValue"),
-    415: .same(proto: "hasDeprecated"),
-    416: .same(proto: "hasDeprecatedLegacyJsonFieldConflicts"),
-    417: .same(proto: "hasDoubleValue"),
-    418: .same(proto: "hasEdition"),
-    419: .same(proto: "hasEnd"),
-    420: .same(proto: "hasEnumType"),
-    421: .same(proto: "hasExtendee"),
-    422: .same(proto: "hasExtensionValue"),
-    423: .same(proto: "hasFeatures"),
-    424: .same(proto: "hasFieldPresence"),
-    425: .same(proto: "hasFullName"),
-    426: .same(proto: "hasGoPackage"),
-    427: .same(proto: "hash"),
-    428: .same(proto: "Hashable"),
-    429: .same(proto: "hasher"),
-    430: .same(proto: "HashVisitor"),
-    431: .same(proto: "hasIdempotencyLevel"),
-    432: .same(proto: "hasIdentifierValue"),
-    433: .same(proto: "hasInputType"),
-    434: .same(proto: "hasIsExtension"),
-    435: .same(proto: "hasJavaGenerateEqualsAndHash"),
-    436: .same(proto: "hasJavaGenericServices"),
-    437: .same(proto: "hasJavaMultipleFiles"),
-    438: .same(proto: "hasJavaOuterClassname"),
-    439: .same(proto: "hasJavaPackage"),
-    440: .same(proto: "hasJavaStringCheckUtf8"),
-    441: .same(proto: "hasJsonFormat"),
-    442: .same(proto: "hasJsonName"),
-    443: .same(proto: "hasJstype"),
-    444: .same(proto: "hasLabel"),
-    445: .same(proto: "hasLazy"),
-    446: .same(proto: "hasLeadingComments"),
-    447: .same(proto: "hasMapEntry"),
-    448: .same(proto: "hasMaximumEdition"),
-    449: .same(proto: "hasMessageEncoding"),
-    450: .same(proto: "hasMessageSetWireFormat"),
-    451: .same(proto: "hasMinimumEdition"),
-    452: .same(proto: "hasName"),
-    453: .same(proto: "hasNamePart"),
-    454: .same(proto: "hasNegativeIntValue"),
-    455: .same(proto: "hasNoStandardDescriptorAccessor"),
-    456: .same(proto: "hasNumber"),
-    457: .same(proto: "hasObjcClassPrefix"),
-    458: .same(proto: "hasOneofIndex"),
-    459: .same(proto: "hasOptimizeFor"),
-    460: .same(proto: "hasOptions"),
-    461: .same(proto: "hasOutputType"),
-    462: .same(proto: "hasPackage"),
-    463: .same(proto: "hasPacked"),
-    464: .same(proto: "hasPhpClassPrefix"),
-    465: .same(proto: "hasPhpGenericServices"),
-    466: .same(proto: "hasPhpMetadataNamespace"),
-    467: .same(proto: "hasPhpNamespace"),
-    468: .same(proto: "hasPositiveIntValue"),
-    469: .same(proto: "hasProto3Optional"),
-    470: .same(proto: "hasPyGenericServices"),
-    471: .same(proto: "hasRepeated"),
-    472: .same(proto: "hasRepeatedFieldEncoding"),
-    473: .same(proto: "hasReserved"),
-    474: .same(proto: "hasRetention"),
-    475: .same(proto: "hasRubyPackage"),
-    476: .same(proto: "hasSemantic"),
-    477: .same(proto: "hasServerStreaming"),
-    478: .same(proto: "hasSourceCodeInfo"),
-    479: .same(proto: "hasSourceContext"),
-    480: .same(proto: "hasSourceFile"),
-    481: .same(proto: "hasStart"),
-    482: .same(proto: "hasStringValue"),
-    483: .same(proto: "hasSwiftPrefix"),
-    484: .same(proto: "hasSyntax"),
-    485: .same(proto: "hasTrailingComments"),
-    486: .same(proto: "hasType"),
-    487: .same(proto: "hasTypeName"),
-    488: .same(proto: "hasUnverifiedLazy"),
-    489: .same(proto: "hasUtf8Validation"),
-    490: .same(proto: "hasValue"),
-    491: .same(proto: "hasVerification"),
-    492: .same(proto: "hasWeak"),
-    493: .same(proto: "hour"),
-    494: .same(proto: "i"),
-    495: .same(proto: "idempotencyLevel"),
-    496: .same(proto: "identifierValue"),
-    497: .same(proto: "if"),
-    498: .same(proto: "ignoreUnknownFields"),
-    499: .same(proto: "index"),
-    500: .same(proto: "init"),
-    501: .same(proto: "inout"),
-    502: .same(proto: "inputType"),
-    503: .same(proto: "insert"),
-    504: .same(proto: "Int"),
-    505: .same(proto: "Int32"),
-    506: .same(proto: "Int32Value"),
-    507: .same(proto: "Int64"),
-    508: .same(proto: "Int64Value"),
-    509: .same(proto: "Int8"),
-    510: .same(proto: "integerLiteral"),
-    511: .same(proto: "IntegerLiteralType"),
-    512: .same(proto: "intern"),
-    513: .same(proto: "Internal"),
-    514: .same(proto: "InternalState"),
-    515: .same(proto: "into"),
-    516: .same(proto: "ints"),
-    517: .same(proto: "isA"),
-    518: .same(proto: "isEqual"),
-    519: .same(proto: "isEqualTo"),
-    520: .same(proto: "isExtension"),
-    521: .same(proto: "isInitialized"),
-    522: .same(proto: "isNegative"),
-    523: .same(proto: "itemTagsEncodedSize"),
-    524: .same(proto: "iterator"),
-    525: .same(proto: "javaGenerateEqualsAndHash"),
-    526: .same(proto: "javaGenericServices"),
-    527: .same(proto: "javaMultipleFiles"),
-    528: .same(proto: "javaOuterClassname"),
-    529: .same(proto: "javaPackage"),
-    530: .same(proto: "javaStringCheckUtf8"),
-    531: .same(proto: "JSONDecoder"),
-    532: .same(proto: "JSONDecodingError"),
-    533: .same(proto: "JSONDecodingOptions"),
-    534: .same(proto: "jsonEncoder"),
-    535: .same(proto: "JSONEncodingError"),
-    536: .same(proto: "JSONEncodingOptions"),
-    537: .same(proto: "JSONEncodingVisitor"),
-    538: .same(proto: "jsonFormat"),
-    539: .same(proto: "JSONMapEncodingVisitor"),
-    540: .same(proto: "jsonName"),
-    541: .same(proto: "jsonPath"),
-    542: .same(proto: "jsonPaths"),
-    543: .same(proto: "JSONScanner"),
-    544: .same(proto: "jsonString"),
-    545: .same(proto: "jsonText"),
-    546: .same(proto: "jsonUTF8Bytes"),
-    547: .same(proto: "jsonUTF8Data"),
-    548: .same(proto: "jstype"),
-    549: .same(proto: "k"),
-    550: .same(proto: "kChunkSize"),
-    551: .same(proto: "Key"),
-    552: .same(proto: "keyField"),
-    553: .same(proto: "keyFieldOpt"),
-    554: .same(proto: "KeyType"),
-    555: .same(proto: "kind"),
-    556: .same(proto: "l"),
-    557: .same(proto: "label"),
-    558: .same(proto: "lazy"),
-    559: .same(proto: "leadingComments"),
-    560: .same(proto: "leadingDetachedComments"),
-    561: .same(proto: "length"),
-    562: .same(proto: "lessThan"),
-    563: .same(proto: "let"),
-    564: .same(proto: "lhs"),
-    565: .same(proto: "list"),
-    566: .same(proto: "listOfMessages"),
-    567: .same(proto: "listValue"),
-    568: .same(proto: "littleEndian"),
-    569: .same(proto: "littleEndianBytes"),
-    570: .same(proto: "load"),
-    571: .same(proto: "localHasher"),
-    572: .same(proto: "location"),
-    573: .same(proto: "M"),
-    574: .same(proto: "major"),
-    575: .same(proto: "makeAsyncIterator"),
-    576: .same(proto: "makeIterator"),
-    577: .same(proto: "mapEntry"),
-    578: .same(proto: "MapKeyType"),
-    579: .same(proto: "mapToMessages"),
-    580: .same(proto: "MapValueType"),
-    581: .same(proto: "mapVisitor"),
-    582: .same(proto: "maximumEdition"),
-    583: .same(proto: "mdayStart"),
-    584: .same(proto: "merge"),
-    585: .same(proto: "message"),
-    586: .same(proto: "messageDepthLimit"),
-    587: .same(proto: "messageEncoding"),
-    588: .same(proto: "MessageExtension"),
-    589: .same(proto: "MessageImplementationBase"),
-    590: .same(proto: "MessageOptions"),
-    591: .same(proto: "MessageSet"),
-    592: .same(proto: "messageSetWireFormat"),
-    593: .same(proto: "messageSize"),
-    594: .same(proto: "messageType"),
-    595: .same(proto: "Method"),
-    596: .same(proto: "MethodDescriptorProto"),
-    597: .same(proto: "MethodOptions"),
-    598: .same(proto: "methods"),
-    599: .same(proto: "min"),
-    600: .same(proto: "minimumEdition"),
-    601: .same(proto: "minor"),
-    602: .same(proto: "Mixin"),
-    603: .same(proto: "mixins"),
-    604: .same(proto: "modifier"),
-    605: .same(proto: "modify"),
-    606: .same(proto: "month"),
-    607: .same(proto: "msgExtension"),
-    608: .same(proto: "mutating"),
-    609: .same(proto: "n"),
-    610: .same(proto: "name"),
-    611: .same(proto: "NameDescription"),
-    612: .same(proto: "NameMap"),
-    613: .same(proto: "NamePart"),
-    614: .same(proto: "names"),
-    615: .same(proto: "nanos"),
-    616: .same(proto: "negativeIntValue"),
-    617: .same(proto: "nestedType"),
-    618: .same(proto: "newL"),
-    619: .same(proto: "newList"),
-    620: .same(proto: "newValue"),
-    621: .same(proto: "next"),
-    622: .same(proto: "nextByte"),
-    623: .same(proto: "nextFieldNumber"),
-    624: .same(proto: "nextVarInt"),
-    625: .same(proto: "nil"),
-    626: .same(proto: "nilLiteral"),
-    627: .same(proto: "noStandardDescriptorAccessor"),
-    628: .same(proto: "nullValue"),
-    629: .same(proto: "number"),
-    630: .same(proto: "numberValue"),
-    631: .same(proto: "objcClassPrefix"),
-    632: .same(proto: "of"),
-    633: .same(proto: "oneofDecl"),
-    634: .same(proto: "OneofDescriptorProto"),
-    635: .same(proto: "oneofIndex"),
-    636: .same(proto: "OneofOptions"),
-    637: .same(proto: "oneofs"),
-    638: .same(proto: "OneOf_Kind"),
-    639: .same(proto: "optimizeFor"),
-    640: .same(proto: "OptimizeMode"),
-    641: .same(proto: "Option"),
-    642: .same(proto: "OptionalEnumExtensionField"),
-    643: .same(proto: "OptionalExtensionField"),
-    644: .same(proto: "OptionalGroupExtensionField"),
-    645: .same(proto: "OptionalMessageExtensionField"),
-    646: .same(proto: "OptionRetention"),
-    647: .same(proto: "options"),
-    648: .same(proto: "OptionTargetType"),
-    649: .same(proto: "other"),
-    650: .same(proto: "others"),
-    651: .same(proto: "out"),
-    652: .same(proto: "outputType"),
-    653: .same(proto: "p"),
-    654: .same(proto: "package"),
-    655: .same(proto: "packed"),
-    656: .same(proto: "PackedEnumExtensionField"),
-    657: .same(proto: "PackedExtensionField"),
-    658: .same(proto: "padding"),
-    659: .same(proto: "parent"),
-    660: .same(proto: "parse"),
-    661: .same(proto: "path"),
-    662: .same(proto: "paths"),
-    663: .same(proto: "payload"),
-    664: .same(proto: "payloadSize"),
-    665: .same(proto: "phpClassPrefix"),
-    666: .same(proto: "phpGenericServices"),
-    667: .same(proto: "phpMetadataNamespace"),
-    668: .same(proto: "phpNamespace"),
-    669: .same(proto: "pos"),
-    670: .same(proto: "positiveIntValue"),
-    671: .same(proto: "prefix"),
-    672: .same(proto: "preserveProtoFieldNames"),
-    673: .same(proto: "preTraverse"),
-    674: .same(proto: "printUnknownFields"),
-    675: .same(proto: "proto2"),
-    676: .same(proto: "proto3DefaultValue"),
-    677: .same(proto: "proto3Optional"),
-    678: .same(proto: "ProtobufAPIVersionCheck"),
-    679: .same(proto: "ProtobufAPIVersion_3"),
-    680: .same(proto: "ProtobufBool"),
-    681: .same(proto: "ProtobufBytes"),
-    682: .same(proto: "ProtobufDouble"),
-    683: .same(proto: "ProtobufEnumMap"),
-    684: .same(proto: "protobufExtension"),
-    685: .same(proto: "ProtobufFixed32"),
-    686: .same(proto: "ProtobufFixed64"),
-    687: .same(proto: "ProtobufFloat"),
-    688: .same(proto: "ProtobufInt32"),
-    689: .same(proto: "ProtobufInt64"),
-    690: .same(proto: "ProtobufMap"),
-    691: .same(proto: "ProtobufMessageMap"),
-    692: .same(proto: "ProtobufSFixed32"),
-    693: .same(proto: "ProtobufSFixed64"),
-    694: .same(proto: "ProtobufSInt32"),
-    695: .same(proto: "ProtobufSInt64"),
-    696: .same(proto: "ProtobufString"),
-    697: .same(proto: "ProtobufUInt32"),
-    698: .same(proto: "ProtobufUInt64"),
-    699: .same(proto: "protobuf_extensionFieldValues"),
-    700: .same(proto: "protobuf_fieldNumber"),
-    701: .same(proto: "protobuf_generated_isEqualTo"),
-    702: .same(proto: "protobuf_nameMap"),
-    703: .same(proto: "protobuf_newField"),
-    704: .same(proto: "protobuf_package"),
-    705: .same(proto: "protocol"),
-    706: .same(proto: "protoFieldName"),
-    707: .same(proto: "protoMessageName"),
-    708: .same(proto: "ProtoNameProviding"),
-    709: .same(proto: "protoPaths"),
-    710: .same(proto: "public"),
-    711: .same(proto: "publicDependency"),
-    712: .same(proto: "putBoolValue"),
-    713: .same(proto: "putBytesValue"),
-    714: .same(proto: "putDoubleValue"),
-    715: .same(proto: "putEnumValue"),
-    716: .same(proto: "putFixedUInt32"),
-    717: .same(proto: "putFixedUInt64"),
-    718: .same(proto: "putFloatValue"),
-    719: .same(proto: "putInt64"),
-    720: .same(proto: "putStringValue"),
-    721: .same(proto: "putUInt64"),
-    722: .same(proto: "putUInt64Hex"),
-    723: .same(proto: "putVarInt"),
-    724: .same(proto: "putZigZagVarInt"),
-    725: .same(proto: "pyGenericServices"),
-    726: .same(proto: "R"),
-    727: .same(proto: "rawChars"),
-    728: .same(proto: "RawRepresentable"),
-    729: .same(proto: "RawValue"),
-    730: .same(proto: "read4HexDigits"),
-    731: .same(proto: "readBytes"),
-    732: .same(proto: "register"),
-    733: .same(proto: "repeated"),
-    734: .same(proto: "RepeatedEnumExtensionField"),
-    735: .same(proto: "RepeatedExtensionField"),
-    736: .same(proto: "repeatedFieldEncoding"),
-    737: .same(proto: "RepeatedGroupExtensionField"),
-    738: .same(proto: "RepeatedMessageExtensionField"),
-    739: .same(proto: "repeating"),
-    740: .same(proto: "requestStreaming"),
-    741: .same(proto: "requestTypeURL"),
-    742: .same(proto: "requiredSize"),
-    743: .same(proto: "responseStreaming"),
-    744: .same(proto: "responseTypeURL"),
-    745: .same(proto: "result"),
-    746: .same(proto: "retention"),
-    747: .same(proto: "rethrows"),
-    748: .same(proto: "return"),
-    749: .same(proto: "ReturnType"),
-    750: .same(proto: "revision"),
-    751: .same(proto: "rhs"),
-    752: .same(proto: "root"),
-    753: .same(proto: "rubyPackage"),
-    754: .same(proto: "s"),
-    755: .same(proto: "sawBackslash"),
-    756: .same(proto: "sawSection4Characters"),
-    757: .same(proto: "sawSection5Characters"),
-    758: .same(proto: "scanner"),
-    759: .same(proto: "seconds"),
-    760: .same(proto: "self"),
-    761: .same(proto: "semantic"),
-    762: .same(proto: "Sendable"),
-    763: .same(proto: "separator"),
-    764: .same(proto: "serialize"),
-    765: .same(proto: "serializedBytes"),
-    766: .same(proto: "serializedData"),
-    767: .same(proto: "serializedSize"),
-    768: .same(proto: "serverStreaming"),
-    769: .same(proto: "service"),
-    770: .same(proto: "ServiceDescriptorProto"),
-    771: .same(proto: "ServiceOptions"),
-    772: .same(proto: "set"),
-    773: .same(proto: "setExtensionValue"),
-    774: .same(proto: "shift"),
-    775: .same(proto: "SimpleExtensionMap"),
-    776: .same(proto: "size"),
-    777: .same(proto: "sizer"),
-    778: .same(proto: "source"),
-    779: .same(proto: "sourceCodeInfo"),
-    780: .same(proto: "sourceContext"),
-    781: .same(proto: "sourceEncoding"),
-    782: .same(proto: "sourceFile"),
-    783: .same(proto: "span"),
-    784: .same(proto: "split"),
-    785: .same(proto: "start"),
-    786: .same(proto: "startArray"),
-    787: .same(proto: "startArrayObject"),
-    788: .same(proto: "startField"),
-    789: .same(proto: "startIndex"),
-    790: .same(proto: "startMessageField"),
-    791: .same(proto: "startObject"),
-    792: .same(proto: "startRegularField"),
-    793: .same(proto: "state"),
-    794: .same(proto: "static"),
-    795: .same(proto: "StaticString"),
-    796: .same(proto: "storage"),
-    797: .same(proto: "String"),
-    798: .same(proto: "stringLiteral"),
-    799: .same(proto: "StringLiteralType"),
-    800: .same(proto: "stringResult"),
-    801: .same(proto: "stringValue"),
-    802: .same(proto: "struct"),
-    803: .same(proto: "structValue"),
-    804: .same(proto: "subDecoder"),
-    805: .same(proto: "subscript"),
-    806: .same(proto: "subVisitor"),
-    807: .same(proto: "Swift"),
-    808: .same(proto: "swiftPrefix"),
-    809: .same(proto: "SwiftProtobufContiguousBytes"),
-    810: .same(proto: "syntax"),
-    811: .same(proto: "T"),
-    812: .same(proto: "tag"),
-    813: .same(proto: "targets"),
-    814: .same(proto: "terminator"),
-    815: .same(proto: "testDecoder"),
-    816: .same(proto: "text"),
-    817: .same(proto: "textDecoder"),
-    818: .same(proto: "TextFormatDecoder"),
-    819: .same(proto: "TextFormatDecodingError"),
-    820: .same(proto: "TextFormatDecodingOptions"),
-    821: .same(proto: "TextFormatEncodingOptions"),
-    822: .same(proto: "TextFormatEncodingVisitor"),
-    823: .same(proto: "textFormatString"),
-    824: .same(proto: "throwOrIgnore"),
-    825: .same(proto: "throws"),
-    826: .same(proto: "timeInterval"),
-    827: .same(proto: "timeIntervalSince1970"),
-    828: .same(proto: "timeIntervalSinceReferenceDate"),
-    829: .same(proto: "Timestamp"),
-    830: .same(proto: "total"),
-    831: .same(proto: "totalArrayDepth"),
-    832: .same(proto: "totalSize"),
-    833: .same(proto: "trailingComments"),
-    834: .same(proto: "traverse"),
-    835: .same(proto: "true"),
-    836: .same(proto: "try"),
-    837: .same(proto: "type"),
-    838: .same(proto: "typealias"),
-    839: .same(proto: "TypeEnum"),
-    840: .same(proto: "typeName"),
-    841: .same(proto: "typePrefix"),
-    842: .same(proto: "typeStart"),
-    843: .same(proto: "typeUnknown"),
-    844: .same(proto: "typeURL"),
-    845: .same(proto: "UInt32"),
-    846: .same(proto: "UInt32Value"),
-    847: .same(proto: "UInt64"),
-    848: .same(proto: "UInt64Value"),
-    849: .same(proto: "UInt8"),
-    850: .same(proto: "unchecked"),
-    851: .same(proto: "unicodeScalarLiteral"),
-    852: .same(proto: "UnicodeScalarLiteralType"),
-    853: .same(proto: "unicodeScalars"),
-    854: .same(proto: "UnicodeScalarView"),
-    855: .same(proto: "uninterpretedOption"),
-    856: .same(proto: "union"),
-    857: .same(proto: "uniqueStorage"),
-    858: .same(proto: "unknown"),
-    859: .same(proto: "unknownFields"),
-    860: .same(proto: "UnknownStorage"),
-    861: .same(proto: "unpackTo"),
-    862: .same(proto: "UnsafeBufferPointer"),
-    863: .same(proto: "UnsafeMutablePointer"),
-    864: .same(proto: "UnsafeMutableRawBufferPointer"),
-    865: .same(proto: "UnsafeRawBufferPointer"),
-    866: .same(proto: "UnsafeRawPointer"),
-    867: .same(proto: "unverifiedLazy"),
-    868: .same(proto: "updatedOptions"),
-    869: .same(proto: "url"),
-    870: .same(proto: "useDeterministicOrdering"),
-    871: .same(proto: "utf8"),
-    872: .same(proto: "utf8Ptr"),
-    873: .same(proto: "utf8ToDouble"),
-    874: .same(proto: "utf8Validation"),
-    875: .same(proto: "UTF8View"),
-    876: .same(proto: "v"),
-    877: .same(proto: "value"),
-    878: .same(proto: "valueField"),
-    879: .same(proto: "values"),
-    880: .same(proto: "ValueType"),
-    881: .same(proto: "var"),
-    882: .same(proto: "verification"),
-    883: .same(proto: "VerificationState"),
-    884: .same(proto: "Version"),
-    885: .same(proto: "versionString"),
-    886: .same(proto: "visitExtensionFields"),
-    887: .same(proto: "visitExtensionFieldsAsMessageSet"),
-    888: .same(proto: "visitMapField"),
-    889: .same(proto: "visitor"),
-    890: .same(proto: "visitPacked"),
-    891: .same(proto: "visitPackedBoolField"),
-    892: .same(proto: "visitPackedDoubleField"),
-    893: .same(proto: "visitPackedEnumField"),
-    894: .same(proto: "visitPackedFixed32Field"),
-    895: .same(proto: "visitPackedFixed64Field"),
-    896: .same(proto: "visitPackedFloatField"),
-    897: .same(proto: "visitPackedInt32Field"),
-    898: .same(proto: "visitPackedInt64Field"),
-    899: .same(proto: "visitPackedSFixed32Field"),
-    900: .same(proto: "visitPackedSFixed64Field"),
-    901: .same(proto: "visitPackedSInt32Field"),
-    902: .same(proto: "visitPackedSInt64Field"),
-    903: .same(proto: "visitPackedUInt32Field"),
-    904: .same(proto: "visitPackedUInt64Field"),
-    905: .same(proto: "visitRepeated"),
-    906: .same(proto: "visitRepeatedBoolField"),
-    907: .same(proto: "visitRepeatedBytesField"),
-    908: .same(proto: "visitRepeatedDoubleField"),
-    909: .same(proto: "visitRepeatedEnumField"),
-    910: .same(proto: "visitRepeatedFixed32Field"),
-    911: .same(proto: "visitRepeatedFixed64Field"),
-    912: .same(proto: "visitRepeatedFloatField"),
-    913: .same(proto: "visitRepeatedGroupField"),
-    914: .same(proto: "visitRepeatedInt32Field"),
-    915: .same(proto: "visitRepeatedInt64Field"),
-    916: .same(proto: "visitRepeatedMessageField"),
-    917: .same(proto: "visitRepeatedSFixed32Field"),
-    918: .same(proto: "visitRepeatedSFixed64Field"),
-    919: .same(proto: "visitRepeatedSInt32Field"),
-    920: .same(proto: "visitRepeatedSInt64Field"),
-    921: .same(proto: "visitRepeatedStringField"),
-    922: .same(proto: "visitRepeatedUInt32Field"),
-    923: .same(proto: "visitRepeatedUInt64Field"),
-    924: .same(proto: "visitSingular"),
-    925: .same(proto: "visitSingularBoolField"),
-    926: .same(proto: "visitSingularBytesField"),
-    927: .same(proto: "visitSingularDoubleField"),
-    928: .same(proto: "visitSingularEnumField"),
-    929: .same(proto: "visitSingularFixed32Field"),
-    930: .same(proto: "visitSingularFixed64Field"),
-    931: .same(proto: "visitSingularFloatField"),
-    932: .same(proto: "visitSingularGroupField"),
-    933: .same(proto: "visitSingularInt32Field"),
-    934: .same(proto: "visitSingularInt64Field"),
-    935: .same(proto: "visitSingularMessageField"),
-    936: .same(proto: "visitSingularSFixed32Field"),
-    937: .same(proto: "visitSingularSFixed64Field"),
-    938: .same(proto: "visitSingularSInt32Field"),
-    939: .same(proto: "visitSingularSInt64Field"),
-    940: .same(proto: "visitSingularStringField"),
-    941: .same(proto: "visitSingularUInt32Field"),
-    942: .same(proto: "visitSingularUInt64Field"),
-    943: .same(proto: "visitUnknown"),
-    944: .same(proto: "wasDecoded"),
-    945: .same(proto: "weak"),
-    946: .same(proto: "weakDependency"),
-    947: .same(proto: "where"),
-    948: .same(proto: "wireFormat"),
-    949: .same(proto: "with"),
-    950: .same(proto: "withUnsafeBytes"),
-    951: .same(proto: "withUnsafeMutableBytes"),
-    952: .same(proto: "work"),
-    953: .same(proto: "Wrapped"),
-    954: .same(proto: "WrappedType"),
-    955: .same(proto: "wrappedValue"),
-    956: .same(proto: "written"),
-    957: .same(proto: "yday"),
+    278: .same(proto: "escaping"),
+    279: .same(proto: "ExpressibleByArrayLiteral"),
+    280: .same(proto: "ExpressibleByDictionaryLiteral"),
+    281: .same(proto: "ext"),
+    282: .same(proto: "extDecoder"),
+    283: .same(proto: "extendedGraphemeClusterLiteral"),
+    284: .same(proto: "ExtendedGraphemeClusterLiteralType"),
+    285: .same(proto: "extendee"),
+    286: .same(proto: "ExtensibleMessage"),
+    287: .same(proto: "extension"),
+    288: .same(proto: "ExtensionField"),
+    289: .same(proto: "extensionFieldNumber"),
+    290: .same(proto: "extensionFields"),
+    291: .same(proto: "extensionFieldsAsMessageSet"),
+    292: .same(proto: "ExtensionFieldValueSet"),
+    293: .same(proto: "ExtensionMap"),
+    294: .same(proto: "extensionRange"),
+    295: .same(proto: "ExtensionRangeOptions"),
+    296: .same(proto: "extensions"),
+    297: .same(proto: "extras"),
+    298: .same(proto: "F"),
+    299: .same(proto: "false"),
+    300: .same(proto: "features"),
+    301: .same(proto: "FeatureSet"),
+    302: .same(proto: "FeatureSetDefaults"),
+    303: .same(proto: "FeatureSetEditionDefault"),
+    304: .same(proto: "field"),
+    305: .same(proto: "fieldData"),
+    306: .same(proto: "FieldDescriptorProto"),
+    307: .same(proto: "FieldMask"),
+    308: .same(proto: "fieldName"),
+    309: .same(proto: "fieldNameCount"),
+    310: .same(proto: "fieldNum"),
+    311: .same(proto: "fieldNumber"),
+    312: .same(proto: "fieldNumberForProto"),
+    313: .same(proto: "FieldOptions"),
+    314: .same(proto: "fieldPresence"),
+    315: .same(proto: "fields"),
+    316: .same(proto: "fieldSize"),
+    317: .same(proto: "FieldTag"),
+    318: .same(proto: "fieldType"),
+    319: .same(proto: "file"),
+    320: .same(proto: "FileDescriptorProto"),
+    321: .same(proto: "FileDescriptorSet"),
+    322: .same(proto: "fileName"),
+    323: .same(proto: "FileOptions"),
+    324: .same(proto: "filter"),
+    325: .same(proto: "final"),
+    326: .same(proto: "first"),
+    327: .same(proto: "firstItem"),
+    328: .same(proto: "Float"),
+    329: .same(proto: "floatLiteral"),
+    330: .same(proto: "FloatLiteralType"),
+    331: .same(proto: "FloatValue"),
+    332: .same(proto: "forMessageName"),
+    333: .same(proto: "formUnion"),
+    334: .same(proto: "forReadingFrom"),
+    335: .same(proto: "forTypeURL"),
+    336: .same(proto: "ForwardParser"),
+    337: .same(proto: "forWritingInto"),
+    338: .same(proto: "from"),
+    339: .same(proto: "fromAscii2"),
+    340: .same(proto: "fromAscii4"),
+    341: .same(proto: "fromByteOffset"),
+    342: .same(proto: "fromHexDigit"),
+    343: .same(proto: "fullName"),
+    344: .same(proto: "func"),
+    345: .same(proto: "G"),
+    346: .same(proto: "GeneratedCodeInfo"),
+    347: .same(proto: "get"),
+    348: .same(proto: "getExtensionValue"),
+    349: .same(proto: "getValue"),
+    350: .same(proto: "googleapis"),
+    351: .same(proto: "Google_Protobuf_Any"),
+    352: .same(proto: "Google_Protobuf_Api"),
+    353: .same(proto: "Google_Protobuf_BoolValue"),
+    354: .same(proto: "Google_Protobuf_BytesValue"),
+    355: .same(proto: "Google_Protobuf_DescriptorProto"),
+    356: .same(proto: "Google_Protobuf_DoubleValue"),
+    357: .same(proto: "Google_Protobuf_Duration"),
+    358: .same(proto: "Google_Protobuf_Edition"),
+    359: .same(proto: "Google_Protobuf_Empty"),
+    360: .same(proto: "Google_Protobuf_Enum"),
+    361: .same(proto: "Google_Protobuf_EnumDescriptorProto"),
+    362: .same(proto: "Google_Protobuf_EnumOptions"),
+    363: .same(proto: "Google_Protobuf_EnumValue"),
+    364: .same(proto: "Google_Protobuf_EnumValueDescriptorProto"),
+    365: .same(proto: "Google_Protobuf_EnumValueOptions"),
+    366: .same(proto: "Google_Protobuf_ExtensionRangeOptions"),
+    367: .same(proto: "Google_Protobuf_FeatureSet"),
+    368: .same(proto: "Google_Protobuf_FeatureSetDefaults"),
+    369: .same(proto: "Google_Protobuf_Field"),
+    370: .same(proto: "Google_Protobuf_FieldDescriptorProto"),
+    371: .same(proto: "Google_Protobuf_FieldMask"),
+    372: .same(proto: "Google_Protobuf_FieldOptions"),
+    373: .same(proto: "Google_Protobuf_FileDescriptorProto"),
+    374: .same(proto: "Google_Protobuf_FileDescriptorSet"),
+    375: .same(proto: "Google_Protobuf_FileOptions"),
+    376: .same(proto: "Google_Protobuf_FloatValue"),
+    377: .same(proto: "Google_Protobuf_GeneratedCodeInfo"),
+    378: .same(proto: "Google_Protobuf_Int32Value"),
+    379: .same(proto: "Google_Protobuf_Int64Value"),
+    380: .same(proto: "Google_Protobuf_ListValue"),
+    381: .same(proto: "Google_Protobuf_MessageOptions"),
+    382: .same(proto: "Google_Protobuf_Method"),
+    383: .same(proto: "Google_Protobuf_MethodDescriptorProto"),
+    384: .same(proto: "Google_Protobuf_MethodOptions"),
+    385: .same(proto: "Google_Protobuf_Mixin"),
+    386: .same(proto: "Google_Protobuf_NullValue"),
+    387: .same(proto: "Google_Protobuf_OneofDescriptorProto"),
+    388: .same(proto: "Google_Protobuf_OneofOptions"),
+    389: .same(proto: "Google_Protobuf_Option"),
+    390: .same(proto: "Google_Protobuf_ServiceDescriptorProto"),
+    391: .same(proto: "Google_Protobuf_ServiceOptions"),
+    392: .same(proto: "Google_Protobuf_SourceCodeInfo"),
+    393: .same(proto: "Google_Protobuf_SourceContext"),
+    394: .same(proto: "Google_Protobuf_StringValue"),
+    395: .same(proto: "Google_Protobuf_Struct"),
+    396: .same(proto: "Google_Protobuf_Syntax"),
+    397: .same(proto: "Google_Protobuf_Timestamp"),
+    398: .same(proto: "Google_Protobuf_Type"),
+    399: .same(proto: "Google_Protobuf_UInt32Value"),
+    400: .same(proto: "Google_Protobuf_UInt64Value"),
+    401: .same(proto: "Google_Protobuf_UninterpretedOption"),
+    402: .same(proto: "Google_Protobuf_Value"),
+    403: .same(proto: "goPackage"),
+    404: .same(proto: "group"),
+    405: .same(proto: "groupFieldNumberStack"),
+    406: .same(proto: "groupSize"),
+    407: .same(proto: "hadOneofValue"),
+    408: .same(proto: "handleConflictingOneOf"),
+    409: .same(proto: "hasAggregateValue"),
+    410: .same(proto: "hasAllowAlias"),
+    411: .same(proto: "hasBegin"),
+    412: .same(proto: "hasCcEnableArenas"),
+    413: .same(proto: "hasCcGenericServices"),
+    414: .same(proto: "hasClientStreaming"),
+    415: .same(proto: "hasCsharpNamespace"),
+    416: .same(proto: "hasCtype"),
+    417: .same(proto: "hasDebugRedact"),
+    418: .same(proto: "hasDefaultValue"),
+    419: .same(proto: "hasDeprecated"),
+    420: .same(proto: "hasDeprecatedLegacyJsonFieldConflicts"),
+    421: .same(proto: "hasDoubleValue"),
+    422: .same(proto: "hasEdition"),
+    423: .same(proto: "hasEnd"),
+    424: .same(proto: "hasEnumType"),
+    425: .same(proto: "hasExtendee"),
+    426: .same(proto: "hasExtensionValue"),
+    427: .same(proto: "hasFeatures"),
+    428: .same(proto: "hasFieldPresence"),
+    429: .same(proto: "hasFullName"),
+    430: .same(proto: "hasGoPackage"),
+    431: .same(proto: "hash"),
+    432: .same(proto: "Hashable"),
+    433: .same(proto: "hasher"),
+    434: .same(proto: "HashVisitor"),
+    435: .same(proto: "hasIdempotencyLevel"),
+    436: .same(proto: "hasIdentifierValue"),
+    437: .same(proto: "hasInputType"),
+    438: .same(proto: "hasIsExtension"),
+    439: .same(proto: "hasJavaGenerateEqualsAndHash"),
+    440: .same(proto: "hasJavaGenericServices"),
+    441: .same(proto: "hasJavaMultipleFiles"),
+    442: .same(proto: "hasJavaOuterClassname"),
+    443: .same(proto: "hasJavaPackage"),
+    444: .same(proto: "hasJavaStringCheckUtf8"),
+    445: .same(proto: "hasJsonFormat"),
+    446: .same(proto: "hasJsonName"),
+    447: .same(proto: "hasJstype"),
+    448: .same(proto: "hasLabel"),
+    449: .same(proto: "hasLazy"),
+    450: .same(proto: "hasLeadingComments"),
+    451: .same(proto: "hasMapEntry"),
+    452: .same(proto: "hasMaximumEdition"),
+    453: .same(proto: "hasMessageEncoding"),
+    454: .same(proto: "hasMessageSetWireFormat"),
+    455: .same(proto: "hasMinimumEdition"),
+    456: .same(proto: "hasName"),
+    457: .same(proto: "hasNamePart"),
+    458: .same(proto: "hasNegativeIntValue"),
+    459: .same(proto: "hasNoStandardDescriptorAccessor"),
+    460: .same(proto: "hasNumber"),
+    461: .same(proto: "hasObjcClassPrefix"),
+    462: .same(proto: "hasOneofIndex"),
+    463: .same(proto: "hasOptimizeFor"),
+    464: .same(proto: "hasOptions"),
+    465: .same(proto: "hasOutputType"),
+    466: .same(proto: "hasPackage"),
+    467: .same(proto: "hasPacked"),
+    468: .same(proto: "hasPhpClassPrefix"),
+    469: .same(proto: "hasPhpGenericServices"),
+    470: .same(proto: "hasPhpMetadataNamespace"),
+    471: .same(proto: "hasPhpNamespace"),
+    472: .same(proto: "hasPositiveIntValue"),
+    473: .same(proto: "hasProto3Optional"),
+    474: .same(proto: "hasPyGenericServices"),
+    475: .same(proto: "hasRepeated"),
+    476: .same(proto: "hasRepeatedFieldEncoding"),
+    477: .same(proto: "hasReserved"),
+    478: .same(proto: "hasRetention"),
+    479: .same(proto: "hasRubyPackage"),
+    480: .same(proto: "hasSemantic"),
+    481: .same(proto: "hasServerStreaming"),
+    482: .same(proto: "hasSourceCodeInfo"),
+    483: .same(proto: "hasSourceContext"),
+    484: .same(proto: "hasSourceFile"),
+    485: .same(proto: "hasStart"),
+    486: .same(proto: "hasStringValue"),
+    487: .same(proto: "hasSwiftPrefix"),
+    488: .same(proto: "hasSyntax"),
+    489: .same(proto: "hasTrailingComments"),
+    490: .same(proto: "hasType"),
+    491: .same(proto: "hasTypeName"),
+    492: .same(proto: "hasUnverifiedLazy"),
+    493: .same(proto: "hasUtf8Validation"),
+    494: .same(proto: "hasValue"),
+    495: .same(proto: "hasVerification"),
+    496: .same(proto: "hasWeak"),
+    497: .same(proto: "hour"),
+    498: .same(proto: "i"),
+    499: .same(proto: "idempotencyLevel"),
+    500: .same(proto: "identifierValue"),
+    501: .same(proto: "if"),
+    502: .same(proto: "ignoreUnknownFields"),
+    503: .same(proto: "index"),
+    504: .same(proto: "init"),
+    505: .same(proto: "inout"),
+    506: .same(proto: "inputType"),
+    507: .same(proto: "insert"),
+    508: .same(proto: "Int"),
+    509: .same(proto: "Int32"),
+    510: .same(proto: "Int32Value"),
+    511: .same(proto: "Int64"),
+    512: .same(proto: "Int64Value"),
+    513: .same(proto: "Int8"),
+    514: .same(proto: "integerLiteral"),
+    515: .same(proto: "IntegerLiteralType"),
+    516: .same(proto: "intern"),
+    517: .same(proto: "Internal"),
+    518: .same(proto: "InternalState"),
+    519: .same(proto: "into"),
+    520: .same(proto: "ints"),
+    521: .same(proto: "isA"),
+    522: .same(proto: "isEqual"),
+    523: .same(proto: "isEqualTo"),
+    524: .same(proto: "isExtension"),
+    525: .same(proto: "isInitialized"),
+    526: .same(proto: "isNegative"),
+    527: .same(proto: "isUnset"),
+    528: .same(proto: "itemTagsEncodedSize"),
+    529: .same(proto: "iterator"),
+    530: .same(proto: "javaGenerateEqualsAndHash"),
+    531: .same(proto: "javaGenericServices"),
+    532: .same(proto: "javaMultipleFiles"),
+    533: .same(proto: "javaOuterClassname"),
+    534: .same(proto: "javaPackage"),
+    535: .same(proto: "javaStringCheckUtf8"),
+    536: .same(proto: "JSONDecoder"),
+    537: .same(proto: "JSONDecodingError"),
+    538: .same(proto: "JSONDecodingOptions"),
+    539: .same(proto: "jsonEncoder"),
+    540: .same(proto: "JSONEncodingError"),
+    541: .same(proto: "JSONEncodingOptions"),
+    542: .same(proto: "JSONEncodingVisitor"),
+    543: .same(proto: "jsonFormat"),
+    544: .same(proto: "JSONMapEncodingVisitor"),
+    545: .same(proto: "jsonName"),
+    546: .same(proto: "jsonPath"),
+    547: .same(proto: "jsonPaths"),
+    548: .same(proto: "JSONScanner"),
+    549: .same(proto: "jsonString"),
+    550: .same(proto: "jsonText"),
+    551: .same(proto: "jsonUTF8Bytes"),
+    552: .same(proto: "jsonUTF8Data"),
+    553: .same(proto: "jstype"),
+    554: .same(proto: "k"),
+    555: .same(proto: "kChunkSize"),
+    556: .same(proto: "Key"),
+    557: .same(proto: "keyField"),
+    558: .same(proto: "keyFieldOpt"),
+    559: .same(proto: "KeyType"),
+    560: .same(proto: "kind"),
+    561: .same(proto: "l"),
+    562: .same(proto: "label"),
+    563: .same(proto: "lazy"),
+    564: .same(proto: "leadingComments"),
+    565: .same(proto: "leadingDetachedComments"),
+    566: .same(proto: "length"),
+    567: .same(proto: "lessThan"),
+    568: .same(proto: "let"),
+    569: .same(proto: "lhs"),
+    570: .same(proto: "list"),
+    571: .same(proto: "listOfMessages"),
+    572: .same(proto: "listValue"),
+    573: .same(proto: "littleEndian"),
+    574: .same(proto: "littleEndianBytes"),
+    575: .same(proto: "load"),
+    576: .same(proto: "localHasher"),
+    577: .same(proto: "location"),
+    578: .same(proto: "M"),
+    579: .same(proto: "major"),
+    580: .same(proto: "makeAsyncIterator"),
+    581: .same(proto: "makeIterator"),
+    582: .same(proto: "map"),
+    583: .same(proto: "mapEntry"),
+    584: .same(proto: "MapKeyType"),
+    585: .same(proto: "mapToMessages"),
+    586: .same(proto: "MapValueType"),
+    587: .same(proto: "mapVisitor"),
+    588: .same(proto: "maximumEdition"),
+    589: .same(proto: "mdayStart"),
+    590: .same(proto: "merge"),
+    591: .same(proto: "message"),
+    592: .same(proto: "messageDepthLimit"),
+    593: .same(proto: "messageEncoding"),
+    594: .same(proto: "MessageExtension"),
+    595: .same(proto: "MessageImplementationBase"),
+    596: .same(proto: "MessageOptions"),
+    597: .same(proto: "MessageSet"),
+    598: .same(proto: "messageSetWireFormat"),
+    599: .same(proto: "messageSize"),
+    600: .same(proto: "messageType"),
+    601: .same(proto: "Method"),
+    602: .same(proto: "MethodDescriptorProto"),
+    603: .same(proto: "MethodOptions"),
+    604: .same(proto: "methods"),
+    605: .same(proto: "min"),
+    606: .same(proto: "minimumEdition"),
+    607: .same(proto: "minor"),
+    608: .same(proto: "Mixin"),
+    609: .same(proto: "mixins"),
+    610: .same(proto: "modifier"),
+    611: .same(proto: "modify"),
+    612: .same(proto: "month"),
+    613: .same(proto: "msgExtension"),
+    614: .same(proto: "mutating"),
+    615: .same(proto: "n"),
+    616: .same(proto: "name"),
+    617: .same(proto: "NameDescription"),
+    618: .same(proto: "NameMap"),
+    619: .same(proto: "NamePart"),
+    620: .same(proto: "names"),
+    621: .same(proto: "nanos"),
+    622: .same(proto: "negativeIntValue"),
+    623: .same(proto: "nestedType"),
+    624: .same(proto: "newL"),
+    625: .same(proto: "newList"),
+    626: .same(proto: "newValue"),
+    627: .same(proto: "next"),
+    628: .same(proto: "nextByte"),
+    629: .same(proto: "nextFieldNumber"),
+    630: .same(proto: "nextVarInt"),
+    631: .same(proto: "nil"),
+    632: .same(proto: "nilLiteral"),
+    633: .same(proto: "noStandardDescriptorAccessor"),
+    634: .same(proto: "nullValue"),
+    635: .same(proto: "number"),
+    636: .same(proto: "numberValue"),
+    637: .same(proto: "objcClassPrefix"),
+    638: .same(proto: "of"),
+    639: .same(proto: "oneOf"),
+    640: .same(proto: "oneofDecl"),
+    641: .same(proto: "OneofDescriptorProto"),
+    642: .same(proto: "oneofIndex"),
+    643: .same(proto: "OneofOptions"),
+    644: .same(proto: "oneofs"),
+    645: .same(proto: "OneOf_Kind"),
+    646: .same(proto: "optimizeFor"),
+    647: .same(proto: "OptimizeMode"),
+    648: .same(proto: "Option"),
+    649: .same(proto: "OptionalEnumExtensionField"),
+    650: .same(proto: "OptionalExtensionField"),
+    651: .same(proto: "OptionalGroupExtensionField"),
+    652: .same(proto: "OptionalMessageExtensionField"),
+    653: .same(proto: "OptionRetention"),
+    654: .same(proto: "options"),
+    655: .same(proto: "OptionTargetType"),
+    656: .same(proto: "other"),
+    657: .same(proto: "others"),
+    658: .same(proto: "out"),
+    659: .same(proto: "outputType"),
+    660: .same(proto: "p"),
+    661: .same(proto: "package"),
+    662: .same(proto: "packed"),
+    663: .same(proto: "packedBool"),
+    664: .same(proto: "packedDouble"),
+    665: .same(proto: "packedEnum"),
+    666: .same(proto: "PackedEnumExtensionField"),
+    667: .same(proto: "PackedExtensionField"),
+    668: .same(proto: "packedFixed32"),
+    669: .same(proto: "packedFixed64"),
+    670: .same(proto: "packedFloat"),
+    671: .same(proto: "packedInt32"),
+    672: .same(proto: "packedInt64"),
+    673: .same(proto: "packedSFixed32"),
+    674: .same(proto: "packedSFixed64"),
+    675: .same(proto: "packedSInt32"),
+    676: .same(proto: "packedSInt64"),
+    677: .same(proto: "packedUInt32"),
+    678: .same(proto: "packedUInt64"),
+    679: .same(proto: "padding"),
+    680: .same(proto: "parent"),
+    681: .same(proto: "parse"),
+    682: .same(proto: "path"),
+    683: .same(proto: "paths"),
+    684: .same(proto: "payload"),
+    685: .same(proto: "payloadSize"),
+    686: .same(proto: "phpClassPrefix"),
+    687: .same(proto: "phpGenericServices"),
+    688: .same(proto: "phpMetadataNamespace"),
+    689: .same(proto: "phpNamespace"),
+    690: .same(proto: "pos"),
+    691: .same(proto: "positiveIntValue"),
+    692: .same(proto: "prefix"),
+    693: .same(proto: "preserveProtoFieldNames"),
+    694: .same(proto: "preTraverse"),
+    695: .same(proto: "printUnknownFields"),
+    696: .same(proto: "proto2"),
+    697: .same(proto: "proto3DefaultValue"),
+    698: .same(proto: "proto3Optional"),
+    699: .same(proto: "ProtobufAPIVersionCheck"),
+    700: .same(proto: "ProtobufAPIVersion_3"),
+    701: .same(proto: "ProtobufBool"),
+    702: .same(proto: "ProtobufBytes"),
+    703: .same(proto: "ProtobufDouble"),
+    704: .same(proto: "ProtobufEnumMap"),
+    705: .same(proto: "protobufExtension"),
+    706: .same(proto: "ProtobufFixed32"),
+    707: .same(proto: "ProtobufFixed64"),
+    708: .same(proto: "ProtobufFloat"),
+    709: .same(proto: "ProtobufInt32"),
+    710: .same(proto: "ProtobufInt64"),
+    711: .same(proto: "ProtobufMap"),
+    712: .same(proto: "ProtobufMessageMap"),
+    713: .same(proto: "ProtobufSFixed32"),
+    714: .same(proto: "ProtobufSFixed64"),
+    715: .same(proto: "ProtobufSInt32"),
+    716: .same(proto: "ProtobufSInt64"),
+    717: .same(proto: "ProtobufString"),
+    718: .same(proto: "ProtobufUInt32"),
+    719: .same(proto: "ProtobufUInt64"),
+    720: .same(proto: "protobuf_extensionFieldValues"),
+    721: .same(proto: "protobuf_fieldNumber"),
+    722: .same(proto: "protobuf_generated_isEqualTo"),
+    723: .same(proto: "protobuf_nameMap"),
+    724: .same(proto: "protobuf_newField"),
+    725: .same(proto: "protobuf_package"),
+    726: .same(proto: "protocol"),
+    727: .same(proto: "protoFieldName"),
+    728: .same(proto: "protoMessageName"),
+    729: .same(proto: "ProtoNameProviding"),
+    730: .same(proto: "protoPaths"),
+    731: .same(proto: "public"),
+    732: .same(proto: "publicDependency"),
+    733: .same(proto: "putBoolValue"),
+    734: .same(proto: "putBytesValue"),
+    735: .same(proto: "putDoubleValue"),
+    736: .same(proto: "putEnumValue"),
+    737: .same(proto: "putFixedUInt32"),
+    738: .same(proto: "putFixedUInt64"),
+    739: .same(proto: "putFloatValue"),
+    740: .same(proto: "putInt64"),
+    741: .same(proto: "putStringValue"),
+    742: .same(proto: "putUInt64"),
+    743: .same(proto: "putUInt64Hex"),
+    744: .same(proto: "putVarInt"),
+    745: .same(proto: "putZigZagVarInt"),
+    746: .same(proto: "pyGenericServices"),
+    747: .same(proto: "R"),
+    748: .same(proto: "rawChars"),
+    749: .same(proto: "RawRepresentable"),
+    750: .same(proto: "RawValue"),
+    751: .same(proto: "read4HexDigits"),
+    752: .same(proto: "readBytes"),
+    753: .same(proto: "register"),
+    754: .same(proto: "repeated"),
+    755: .same(proto: "repeatedBool"),
+    756: .same(proto: "repeatedBytes"),
+    757: .same(proto: "repeatedDouble"),
+    758: .same(proto: "repeatedEnum"),
+    759: .same(proto: "RepeatedEnumExtensionField"),
+    760: .same(proto: "RepeatedExtensionField"),
+    761: .same(proto: "repeatedFieldEncoding"),
+    762: .same(proto: "repeatedFixed32"),
+    763: .same(proto: "repeatedFixed64"),
+    764: .same(proto: "repeatedFloat"),
+    765: .same(proto: "repeatedGroup"),
+    766: .same(proto: "RepeatedGroupExtensionField"),
+    767: .same(proto: "repeatedInt32"),
+    768: .same(proto: "repeatedInt64"),
+    769: .same(proto: "repeatedMessage"),
+    770: .same(proto: "RepeatedMessageExtensionField"),
+    771: .same(proto: "repeatedSFixed32"),
+    772: .same(proto: "repeatedSFixed64"),
+    773: .same(proto: "repeatedSInt32"),
+    774: .same(proto: "repeatedSInt64"),
+    775: .same(proto: "repeatedString"),
+    776: .same(proto: "repeatedUInt32"),
+    777: .same(proto: "repeatedUInt64"),
+    778: .same(proto: "repeating"),
+    779: .same(proto: "requestStreaming"),
+    780: .same(proto: "requestTypeURL"),
+    781: .same(proto: "requiredSize"),
+    782: .same(proto: "responseStreaming"),
+    783: .same(proto: "responseTypeURL"),
+    784: .same(proto: "result"),
+    785: .same(proto: "retention"),
+    786: .same(proto: "rethrows"),
+    787: .same(proto: "return"),
+    788: .same(proto: "ReturnType"),
+    789: .same(proto: "revision"),
+    790: .same(proto: "rhs"),
+    791: .same(proto: "root"),
+    792: .same(proto: "rubyPackage"),
+    793: .same(proto: "s"),
+    794: .same(proto: "sawBackslash"),
+    795: .same(proto: "sawSection4Characters"),
+    796: .same(proto: "sawSection5Characters"),
+    797: .same(proto: "scanner"),
+    798: .same(proto: "seconds"),
+    799: .same(proto: "self"),
+    800: .same(proto: "semantic"),
+    801: .same(proto: "Sendable"),
+    802: .same(proto: "separator"),
+    803: .same(proto: "serialize"),
+    804: .same(proto: "serializedBytes"),
+    805: .same(proto: "serializedData"),
+    806: .same(proto: "serializedSize"),
+    807: .same(proto: "serverStreaming"),
+    808: .same(proto: "service"),
+    809: .same(proto: "ServiceDescriptorProto"),
+    810: .same(proto: "ServiceOptions"),
+    811: .same(proto: "set"),
+    812: .same(proto: "setExtensionValue"),
+    813: .same(proto: "shift"),
+    814: .same(proto: "SimpleExtensionMap"),
+    815: .same(proto: "singularBool"),
+    816: .same(proto: "singularBytes"),
+    817: .same(proto: "singularDouble"),
+    818: .same(proto: "singularEnum"),
+    819: .same(proto: "singularFixed32"),
+    820: .same(proto: "singularFixed64"),
+    821: .same(proto: "singularFloat"),
+    822: .same(proto: "singularGroup"),
+    823: .same(proto: "singularInt32"),
+    824: .same(proto: "singularInt64"),
+    825: .same(proto: "singularMessage"),
+    826: .same(proto: "singularSFixed32"),
+    827: .same(proto: "singularSFixed64"),
+    828: .same(proto: "singularSInt32"),
+    829: .same(proto: "singularSInt64"),
+    830: .same(proto: "singularString"),
+    831: .same(proto: "singularUInt32"),
+    832: .same(proto: "singularUInt64"),
+    833: .same(proto: "size"),
+    834: .same(proto: "sizer"),
+    835: .same(proto: "source"),
+    836: .same(proto: "sourceCodeInfo"),
+    837: .same(proto: "sourceContext"),
+    838: .same(proto: "sourceEncoding"),
+    839: .same(proto: "sourceFile"),
+    840: .same(proto: "span"),
+    841: .same(proto: "split"),
+    842: .same(proto: "start"),
+    843: .same(proto: "startArray"),
+    844: .same(proto: "startArrayObject"),
+    845: .same(proto: "startField"),
+    846: .same(proto: "startIndex"),
+    847: .same(proto: "startMessageField"),
+    848: .same(proto: "startObject"),
+    849: .same(proto: "startRegularField"),
+    850: .same(proto: "state"),
+    851: .same(proto: "static"),
+    852: .same(proto: "StaticString"),
+    853: .same(proto: "storage"),
+    854: .same(proto: "String"),
+    855: .same(proto: "stringLiteral"),
+    856: .same(proto: "StringLiteralType"),
+    857: .same(proto: "stringResult"),
+    858: .same(proto: "stringValue"),
+    859: .same(proto: "struct"),
+    860: .same(proto: "structValue"),
+    861: .same(proto: "subDecoder"),
+    862: .same(proto: "subscript"),
+    863: .same(proto: "subVisitor"),
+    864: .same(proto: "Swift"),
+    865: .same(proto: "swiftPrefix"),
+    866: .same(proto: "SwiftProtobufContiguousBytes"),
+    867: .same(proto: "syntax"),
+    868: .same(proto: "T"),
+    869: .same(proto: "tag"),
+    870: .same(proto: "targets"),
+    871: .same(proto: "terminator"),
+    872: .same(proto: "testDecoder"),
+    873: .same(proto: "text"),
+    874: .same(proto: "textDecoder"),
+    875: .same(proto: "TextFormatDecoder"),
+    876: .same(proto: "TextFormatDecodingError"),
+    877: .same(proto: "TextFormatDecodingOptions"),
+    878: .same(proto: "TextFormatEncodingOptions"),
+    879: .same(proto: "TextFormatEncodingVisitor"),
+    880: .same(proto: "textFormatString"),
+    881: .same(proto: "throwOrIgnore"),
+    882: .same(proto: "throws"),
+    883: .same(proto: "timeInterval"),
+    884: .same(proto: "timeIntervalSince1970"),
+    885: .same(proto: "timeIntervalSinceReferenceDate"),
+    886: .same(proto: "Timestamp"),
+    887: .same(proto: "toConcrete"),
+    888: .same(proto: "total"),
+    889: .same(proto: "totalArrayDepth"),
+    890: .same(proto: "totalSize"),
+    891: .same(proto: "trailingComments"),
+    892: .same(proto: "traverse"),
+    893: .same(proto: "true"),
+    894: .same(proto: "try"),
+    895: .same(proto: "type"),
+    896: .same(proto: "typealias"),
+    897: .same(proto: "TypeEnum"),
+    898: .same(proto: "typeName"),
+    899: .same(proto: "typePrefix"),
+    900: .same(proto: "typeStart"),
+    901: .same(proto: "typeUnknown"),
+    902: .same(proto: "typeURL"),
+    903: .same(proto: "UInt32"),
+    904: .same(proto: "UInt32Value"),
+    905: .same(proto: "UInt64"),
+    906: .same(proto: "UInt64Value"),
+    907: .same(proto: "UInt8"),
+    908: .same(proto: "unchecked"),
+    909: .same(proto: "unicodeScalarLiteral"),
+    910: .same(proto: "UnicodeScalarLiteralType"),
+    911: .same(proto: "unicodeScalars"),
+    912: .same(proto: "UnicodeScalarView"),
+    913: .same(proto: "uninterpretedOption"),
+    914: .same(proto: "union"),
+    915: .same(proto: "uniqueStorage"),
+    916: .same(proto: "unknown"),
+    917: .same(proto: "unknownFields"),
+    918: .same(proto: "UnknownStorage"),
+    919: .same(proto: "unpackTo"),
+    920: .same(proto: "UnsafeBufferPointer"),
+    921: .same(proto: "UnsafeMutablePointer"),
+    922: .same(proto: "UnsafeMutableRawBufferPointer"),
+    923: .same(proto: "UnsafeRawBufferPointer"),
+    924: .same(proto: "UnsafeRawPointer"),
+    925: .same(proto: "unverifiedLazy"),
+    926: .same(proto: "updatedOptions"),
+    927: .same(proto: "url"),
+    928: .same(proto: "useDeterministicOrdering"),
+    929: .same(proto: "utf8"),
+    930: .same(proto: "utf8Ptr"),
+    931: .same(proto: "utf8ToDouble"),
+    932: .same(proto: "utf8Validation"),
+    933: .same(proto: "UTF8View"),
+    934: .same(proto: "v"),
+    935: .same(proto: "value"),
+    936: .same(proto: "valueField"),
+    937: .same(proto: "values"),
+    938: .same(proto: "ValueType"),
+    939: .same(proto: "var"),
+    940: .same(proto: "verification"),
+    941: .same(proto: "VerificationState"),
+    942: .same(proto: "Version"),
+    943: .same(proto: "versionString"),
+    944: .same(proto: "visitExtensionFields"),
+    945: .same(proto: "visitExtensionFieldsAsMessageSet"),
+    946: .same(proto: "visitMapField"),
+    947: .same(proto: "visitor"),
+    948: .same(proto: "visitPacked"),
+    949: .same(proto: "visitPackedBoolField"),
+    950: .same(proto: "visitPackedDoubleField"),
+    951: .same(proto: "visitPackedEnumField"),
+    952: .same(proto: "visitPackedFixed32Field"),
+    953: .same(proto: "visitPackedFixed64Field"),
+    954: .same(proto: "visitPackedFloatField"),
+    955: .same(proto: "visitPackedInt32Field"),
+    956: .same(proto: "visitPackedInt64Field"),
+    957: .same(proto: "visitPackedSFixed32Field"),
+    958: .same(proto: "visitPackedSFixed64Field"),
+    959: .same(proto: "visitPackedSInt32Field"),
+    960: .same(proto: "visitPackedSInt64Field"),
+    961: .same(proto: "visitPackedUInt32Field"),
+    962: .same(proto: "visitPackedUInt64Field"),
+    963: .same(proto: "visitRepeated"),
+    964: .same(proto: "visitRepeatedBoolField"),
+    965: .same(proto: "visitRepeatedBytesField"),
+    966: .same(proto: "visitRepeatedDoubleField"),
+    967: .same(proto: "visitRepeatedEnumField"),
+    968: .same(proto: "visitRepeatedFixed32Field"),
+    969: .same(proto: "visitRepeatedFixed64Field"),
+    970: .same(proto: "visitRepeatedFloatField"),
+    971: .same(proto: "visitRepeatedGroupField"),
+    972: .same(proto: "visitRepeatedInt32Field"),
+    973: .same(proto: "visitRepeatedInt64Field"),
+    974: .same(proto: "visitRepeatedMessageField"),
+    975: .same(proto: "visitRepeatedSFixed32Field"),
+    976: .same(proto: "visitRepeatedSFixed64Field"),
+    977: .same(proto: "visitRepeatedSInt32Field"),
+    978: .same(proto: "visitRepeatedSInt64Field"),
+    979: .same(proto: "visitRepeatedStringField"),
+    980: .same(proto: "visitRepeatedUInt32Field"),
+    981: .same(proto: "visitRepeatedUInt64Field"),
+    982: .same(proto: "visitSingular"),
+    983: .same(proto: "visitSingularBoolField"),
+    984: .same(proto: "visitSingularBytesField"),
+    985: .same(proto: "visitSingularDoubleField"),
+    986: .same(proto: "visitSingularEnumField"),
+    987: .same(proto: "visitSingularFixed32Field"),
+    988: .same(proto: "visitSingularFixed64Field"),
+    989: .same(proto: "visitSingularFloatField"),
+    990: .same(proto: "visitSingularGroupField"),
+    991: .same(proto: "visitSingularInt32Field"),
+    992: .same(proto: "visitSingularInt64Field"),
+    993: .same(proto: "visitSingularMessageField"),
+    994: .same(proto: "visitSingularSFixed32Field"),
+    995: .same(proto: "visitSingularSFixed64Field"),
+    996: .same(proto: "visitSingularSInt32Field"),
+    997: .same(proto: "visitSingularSInt64Field"),
+    998: .same(proto: "visitSingularStringField"),
+    999: .same(proto: "visitSingularUInt32Field"),
+    1000: .same(proto: "visitSingularUInt64Field"),
+    1001: .same(proto: "visitUnknown"),
+    1002: .same(proto: "wasDecoded"),
+    1003: .same(proto: "weak"),
+    1004: .same(proto: "weakDependency"),
+    1005: .same(proto: "where"),
+    1006: .same(proto: "wireFormat"),
+    1007: .same(proto: "with"),
+    1008: .same(proto: "withUnsafeBytes"),
+    1009: .same(proto: "withUnsafeMutableBytes"),
+    1010: .same(proto: "work"),
+    1011: .same(proto: "Wrapped"),
+    1012: .same(proto: "WrappedType"),
+    1013: .same(proto: "wrappedValue"),
+    1014: .same(proto: "written"),
+    1015: .same(proto: "yday"),
   ]
 }
diff --git a/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift b/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift
index 89bc84e72..9658f6b21 100644
--- a/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift
+++ b/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift
@@ -8341,6 +8341,36 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable {
 
   }
 
+  enum escaping: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneEscaping // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneEscaping
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneEscaping
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneEscaping: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.escaping] = [
+      .noneEscaping,
+    ]
+
+  }
+
   enum ExpressibleByArrayLiteral: SwiftProtobuf.Enum {
     typealias RawValue = Int
     case noneExpressibleByArrayLiteral // = 0
@@ -8671,6 +8701,66 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable {
 
   }
 
+  enum extensionFields: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneExtensionFields // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneExtensionFields
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneExtensionFields
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneExtensionFields: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionFields] = [
+      .noneExtensionFields,
+    ]
+
+  }
+
+  enum extensionFieldsAsMessageSet: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneExtensionFieldsAsMessageSet // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneExtensionFieldsAsMessageSet
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneExtensionFieldsAsMessageSet
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneExtensionFieldsAsMessageSet: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionFieldsAsMessageSet] = [
+      .noneExtensionFieldsAsMessageSet,
+    ]
+
+  }
+
   enum ExtensionFieldValueSet: SwiftProtobuf.Enum {
     typealias RawValue = Int
     case noneExtensionFieldValueSet // = 0
@@ -10381,6 +10471,36 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable {
 
   }
 
+  enum getValue: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneGetValue // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneGetValue
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneGetValue
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneGetValue: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.getValue] = [
+      .noneGetValue,
+    ]
+
+  }
+
   enum googleapis: SwiftProtobuf.Enum {
     typealias RawValue = Int
     case noneGoogleapis // = 0
@@ -15691,6 +15811,36 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable {
 
   }
 
+  enum isUnset: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneIsUnset // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneIsUnset
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneIsUnset
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneIsUnset: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isUnset] = [
+      .noneIsUnset,
+    ]
+
+  }
+
   enum itemTagsEncodedSize: SwiftProtobuf.Enum {
     typealias RawValue = Int
     case noneItemTagsEncodedSize // = 0
@@ -17311,6 +17461,36 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable {
 
   }
 
+  enum map: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneMap // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneMap
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneMap
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneMap: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.map] = [
+      .noneMap,
+    ]
+
+  }
+
   enum mapEntry: SwiftProtobuf.Enum {
     typealias RawValue = Int
     case noneMapEntry // = 0
@@ -18991,6 +19171,36 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable {
 
   }
 
+  enum oneOf: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneOneOf // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneOneOf
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneOneOf
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneOneOf: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneOf] = [
+      .noneOneOf,
+    ]
+
+  }
+
   enum oneofDecl: SwiftProtobuf.Enum {
     typealias RawValue = Int
     case noneOneofDecl // = 0
@@ -19681,3602 +19891,5102 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable {
 
   }
 
-  enum PackedEnumExtensionField: SwiftProtobuf.Enum {
+  enum packedBool: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePackedEnumExtensionField // = 0
+    case nonePackedBool // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePackedEnumExtensionField
+      self = .nonePackedBool
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePackedEnumExtensionField
+      case 0: self = .nonePackedBool
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePackedEnumExtensionField: return 0
+      case .nonePackedBool: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedEnumExtensionField] = [
-      .nonePackedEnumExtensionField,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedBool] = [
+      .nonePackedBool,
     ]
 
   }
 
-  enum PackedExtensionField: SwiftProtobuf.Enum {
+  enum packedDouble: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePackedExtensionField // = 0
+    case nonePackedDouble // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePackedExtensionField
+      self = .nonePackedDouble
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePackedExtensionField
+      case 0: self = .nonePackedDouble
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePackedExtensionField: return 0
+      case .nonePackedDouble: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedExtensionField] = [
-      .nonePackedExtensionField,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedDouble] = [
+      .nonePackedDouble,
     ]
 
   }
 
-  enum padding: SwiftProtobuf.Enum {
+  enum packedEnum: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePadding // = 0
+    case nonePackedEnum // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePadding
+      self = .nonePackedEnum
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePadding
+      case 0: self = .nonePackedEnum
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePadding: return 0
+      case .nonePackedEnum: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.padding] = [
-      .nonePadding,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedEnum] = [
+      .nonePackedEnum,
     ]
 
   }
 
-  enum parent: SwiftProtobuf.Enum {
+  enum PackedEnumExtensionField: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneParent // = 0
+    case nonePackedEnumExtensionField // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneParent
+      self = .nonePackedEnumExtensionField
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneParent
+      case 0: self = .nonePackedEnumExtensionField
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneParent: return 0
+      case .nonePackedEnumExtensionField: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parent] = [
-      .noneParent,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedEnumExtensionField] = [
+      .nonePackedEnumExtensionField,
     ]
 
   }
 
-  enum parse: SwiftProtobuf.Enum {
+  enum PackedExtensionField: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneParse // = 0
+    case nonePackedExtensionField // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneParse
+      self = .nonePackedExtensionField
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneParse
+      case 0: self = .nonePackedExtensionField
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneParse: return 0
+      case .nonePackedExtensionField: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parse] = [
-      .noneParse,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedExtensionField] = [
+      .nonePackedExtensionField,
     ]
 
   }
 
-  enum path: SwiftProtobuf.Enum {
+  enum packedFixed32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePath // = 0
+    case nonePackedFixed32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePath
+      self = .nonePackedFixed32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePath
+      case 0: self = .nonePackedFixed32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePath: return 0
+      case .nonePackedFixed32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.path] = [
-      .nonePath,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedFixed32] = [
+      .nonePackedFixed32,
     ]
 
   }
 
-  enum paths: SwiftProtobuf.Enum {
+  enum packedFixed64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePaths // = 0
+    case nonePackedFixed64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePaths
+      self = .nonePackedFixed64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePaths
+      case 0: self = .nonePackedFixed64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePaths: return 0
+      case .nonePackedFixed64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.paths] = [
-      .nonePaths,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedFixed64] = [
+      .nonePackedFixed64,
     ]
 
   }
 
-  enum payload: SwiftProtobuf.Enum {
+  enum packedFloat: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePayload // = 0
+    case nonePackedFloat // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePayload
+      self = .nonePackedFloat
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePayload
+      case 0: self = .nonePackedFloat
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePayload: return 0
+      case .nonePackedFloat: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payload] = [
-      .nonePayload,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedFloat] = [
+      .nonePackedFloat,
     ]
 
   }
 
-  enum payloadSize: SwiftProtobuf.Enum {
+  enum packedInt32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePayloadSize // = 0
+    case nonePackedInt32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePayloadSize
+      self = .nonePackedInt32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePayloadSize
+      case 0: self = .nonePackedInt32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePayloadSize: return 0
+      case .nonePackedInt32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payloadSize] = [
-      .nonePayloadSize,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedInt32] = [
+      .nonePackedInt32,
     ]
 
   }
 
-  enum phpClassPrefix: SwiftProtobuf.Enum {
+  enum packedInt64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePhpClassPrefix // = 0
+    case nonePackedInt64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePhpClassPrefix
+      self = .nonePackedInt64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePhpClassPrefix
+      case 0: self = .nonePackedInt64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePhpClassPrefix: return 0
+      case .nonePackedInt64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpClassPrefix] = [
-      .nonePhpClassPrefix,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedInt64] = [
+      .nonePackedInt64,
     ]
 
   }
 
-  enum phpGenericServices: SwiftProtobuf.Enum {
+  enum packedSFixed32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePhpGenericServices // = 0
+    case nonePackedSfixed32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePhpGenericServices
+      self = .nonePackedSfixed32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePhpGenericServices
+      case 0: self = .nonePackedSfixed32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePhpGenericServices: return 0
+      case .nonePackedSfixed32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpGenericServices] = [
-      .nonePhpGenericServices,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedSFixed32] = [
+      .nonePackedSfixed32,
     ]
 
   }
 
-  enum phpMetadataNamespace: SwiftProtobuf.Enum {
+  enum packedSFixed64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePhpMetadataNamespace // = 0
+    case nonePackedSfixed64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePhpMetadataNamespace
+      self = .nonePackedSfixed64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePhpMetadataNamespace
+      case 0: self = .nonePackedSfixed64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePhpMetadataNamespace: return 0
+      case .nonePackedSfixed64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpMetadataNamespace] = [
-      .nonePhpMetadataNamespace,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedSFixed64] = [
+      .nonePackedSfixed64,
     ]
 
   }
 
-  enum phpNamespace: SwiftProtobuf.Enum {
+  enum packedSInt32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePhpNamespace // = 0
+    case nonePackedSint32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePhpNamespace
+      self = .nonePackedSint32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePhpNamespace
+      case 0: self = .nonePackedSint32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePhpNamespace: return 0
+      case .nonePackedSint32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpNamespace] = [
-      .nonePhpNamespace,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedSInt32] = [
+      .nonePackedSint32,
     ]
 
   }
 
-  enum pos: SwiftProtobuf.Enum {
+  enum packedSInt64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePos // = 0
+    case nonePackedSint64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePos
+      self = .nonePackedSint64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePos
+      case 0: self = .nonePackedSint64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePos: return 0
+      case .nonePackedSint64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pos] = [
-      .nonePos,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedSInt64] = [
+      .nonePackedSint64,
     ]
 
   }
 
-  enum positiveIntValue: SwiftProtobuf.Enum {
+  enum packedUInt32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePositiveIntValue // = 0
+    case nonePackedUint32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePositiveIntValue
+      self = .nonePackedUint32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePositiveIntValue
+      case 0: self = .nonePackedUint32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePositiveIntValue: return 0
+      case .nonePackedUint32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.positiveIntValue] = [
-      .nonePositiveIntValue,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedUInt32] = [
+      .nonePackedUint32,
     ]
 
   }
 
-  enum prefix: SwiftProtobuf.Enum {
+  enum packedUInt64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePrefix // = 0
+    case nonePackedUint64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePrefix
+      self = .nonePackedUint64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePrefix
+      case 0: self = .nonePackedUint64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePrefix: return 0
+      case .nonePackedUint64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prefix] = [
-      .nonePrefix,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedUInt64] = [
+      .nonePackedUint64,
     ]
 
   }
 
-  enum preserveProtoFieldNames: SwiftProtobuf.Enum {
+  enum padding: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePreserveProtoFieldNames // = 0
+    case nonePadding // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePreserveProtoFieldNames
+      self = .nonePadding
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePreserveProtoFieldNames
+      case 0: self = .nonePadding
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePreserveProtoFieldNames: return 0
+      case .nonePadding: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preserveProtoFieldNames] = [
-      .nonePreserveProtoFieldNames,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.padding] = [
+      .nonePadding,
     ]
 
   }
 
-  enum preTraverse: SwiftProtobuf.Enum {
+  enum parent: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePreTraverse // = 0
+    case noneParent // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePreTraverse
+      self = .noneParent
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePreTraverse
+      case 0: self = .noneParent
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePreTraverse: return 0
+      case .noneParent: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preTraverse] = [
-      .nonePreTraverse,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parent] = [
+      .noneParent,
     ]
 
   }
 
-  enum printUnknownFields: SwiftProtobuf.Enum {
+  enum parse: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePrintUnknownFields // = 0
+    case noneParse // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePrintUnknownFields
+      self = .noneParse
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePrintUnknownFields
+      case 0: self = .noneParse
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePrintUnknownFields: return 0
+      case .noneParse: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.printUnknownFields] = [
-      .nonePrintUnknownFields,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parse] = [
+      .noneParse,
     ]
 
   }
 
-  enum proto2: SwiftProtobuf.Enum {
+  enum path: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProto2 // = 0
+    case nonePath // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProto2
+      self = .nonePath
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProto2
+      case 0: self = .nonePath
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProto2: return 0
+      case .nonePath: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto2] = [
-      .noneProto2,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.path] = [
+      .nonePath,
     ]
 
   }
 
-  enum proto3DefaultValue: SwiftProtobuf.Enum {
+  enum paths: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProto3DefaultValue // = 0
+    case nonePaths // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProto3DefaultValue
+      self = .nonePaths
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProto3DefaultValue
+      case 0: self = .nonePaths
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProto3DefaultValue: return 0
+      case .nonePaths: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3DefaultValue] = [
-      .noneProto3DefaultValue,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.paths] = [
+      .nonePaths,
     ]
 
   }
 
-  enum proto3Optional: SwiftProtobuf.Enum {
+  enum payload: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProto3Optional // = 0
+    case nonePayload // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProto3Optional
+      self = .nonePayload
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProto3Optional
+      case 0: self = .nonePayload
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProto3Optional: return 0
+      case .nonePayload: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3Optional] = [
-      .noneProto3Optional,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payload] = [
+      .nonePayload,
     ]
 
   }
 
-  enum ProtobufAPIVersionCheck: SwiftProtobuf.Enum {
+  enum payloadSize: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufApiversionCheck // = 0
+    case nonePayloadSize // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufApiversionCheck
+      self = .nonePayloadSize
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufApiversionCheck
+      case 0: self = .nonePayloadSize
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufApiversionCheck: return 0
+      case .nonePayloadSize: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck] = [
-      .noneProtobufApiversionCheck,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payloadSize] = [
+      .nonePayloadSize,
     ]
 
   }
 
-  enum ProtobufAPIVersion_3: SwiftProtobuf.Enum {
+  enum phpClassPrefix: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufApiversion3 // = 0
+    case nonePhpClassPrefix // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufApiversion3
+      self = .nonePhpClassPrefix
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufApiversion3
+      case 0: self = .nonePhpClassPrefix
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufApiversion3: return 0
+      case .nonePhpClassPrefix: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_3] = [
-      .noneProtobufApiversion3,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpClassPrefix] = [
+      .nonePhpClassPrefix,
     ]
 
   }
 
-  enum ProtobufBool: SwiftProtobuf.Enum {
+  enum phpGenericServices: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufBool // = 0
+    case nonePhpGenericServices // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufBool
+      self = .nonePhpGenericServices
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufBool
+      case 0: self = .nonePhpGenericServices
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufBool: return 0
+      case .nonePhpGenericServices: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBool] = [
-      .noneProtobufBool,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpGenericServices] = [
+      .nonePhpGenericServices,
     ]
 
   }
 
-  enum ProtobufBytes: SwiftProtobuf.Enum {
+  enum phpMetadataNamespace: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufBytes // = 0
+    case nonePhpMetadataNamespace // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufBytes
+      self = .nonePhpMetadataNamespace
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufBytes
+      case 0: self = .nonePhpMetadataNamespace
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufBytes: return 0
+      case .nonePhpMetadataNamespace: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBytes] = [
-      .noneProtobufBytes,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpMetadataNamespace] = [
+      .nonePhpMetadataNamespace,
     ]
 
   }
 
-  enum ProtobufDouble: SwiftProtobuf.Enum {
+  enum phpNamespace: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufDouble // = 0
+    case nonePhpNamespace // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufDouble
+      self = .nonePhpNamespace
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufDouble
+      case 0: self = .nonePhpNamespace
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufDouble: return 0
+      case .nonePhpNamespace: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufDouble] = [
-      .noneProtobufDouble,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpNamespace] = [
+      .nonePhpNamespace,
     ]
 
   }
 
-  enum ProtobufEnumMap: SwiftProtobuf.Enum {
+  enum pos: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufEnumMap // = 0
+    case nonePos // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufEnumMap
+      self = .nonePos
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufEnumMap
+      case 0: self = .nonePos
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufEnumMap: return 0
+      case .nonePos: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufEnumMap] = [
-      .noneProtobufEnumMap,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pos] = [
+      .nonePos,
     ]
 
   }
 
-  enum protobufExtension: SwiftProtobuf.Enum {
+  enum positiveIntValue: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufExtension // = 0
+    case nonePositiveIntValue // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufExtension
+      self = .nonePositiveIntValue
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufExtension
+      case 0: self = .nonePositiveIntValue
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufExtension: return 0
+      case .nonePositiveIntValue: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufExtension] = [
-      .noneProtobufExtension,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.positiveIntValue] = [
+      .nonePositiveIntValue,
     ]
 
   }
 
-  enum ProtobufFixed32: SwiftProtobuf.Enum {
+  enum prefix: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufFixed32 // = 0
+    case nonePrefix // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufFixed32
+      self = .nonePrefix
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufFixed32
+      case 0: self = .nonePrefix
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufFixed32: return 0
+      case .nonePrefix: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed32] = [
-      .noneProtobufFixed32,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prefix] = [
+      .nonePrefix,
     ]
 
   }
 
-  enum ProtobufFixed64: SwiftProtobuf.Enum {
+  enum preserveProtoFieldNames: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufFixed64 // = 0
+    case nonePreserveProtoFieldNames // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufFixed64
+      self = .nonePreserveProtoFieldNames
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufFixed64
+      case 0: self = .nonePreserveProtoFieldNames
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufFixed64: return 0
+      case .nonePreserveProtoFieldNames: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed64] = [
-      .noneProtobufFixed64,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preserveProtoFieldNames] = [
+      .nonePreserveProtoFieldNames,
     ]
 
   }
 
-  enum ProtobufFloat: SwiftProtobuf.Enum {
+  enum preTraverse: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufFloat // = 0
+    case nonePreTraverse // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufFloat
+      self = .nonePreTraverse
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufFloat
+      case 0: self = .nonePreTraverse
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufFloat: return 0
+      case .nonePreTraverse: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFloat] = [
-      .noneProtobufFloat,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preTraverse] = [
+      .nonePreTraverse,
     ]
 
   }
 
-  enum ProtobufInt32: SwiftProtobuf.Enum {
+  enum printUnknownFields: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePrintUnknownFields // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePrintUnknownFields
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePrintUnknownFields
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePrintUnknownFields: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.printUnknownFields] = [
+      .nonePrintUnknownFields,
+    ]
+
+  }
+
+  enum proto2: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProto2 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProto2
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProto2
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProto2: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto2] = [
+      .noneProto2,
+    ]
+
+  }
+
+  enum proto3DefaultValue: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProto3DefaultValue // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProto3DefaultValue
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProto3DefaultValue
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProto3DefaultValue: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3DefaultValue] = [
+      .noneProto3DefaultValue,
+    ]
+
+  }
+
+  enum proto3Optional: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProto3Optional // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProto3Optional
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProto3Optional
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProto3Optional: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3Optional] = [
+      .noneProto3Optional,
+    ]
+
+  }
+
+  enum ProtobufAPIVersionCheck: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufApiversionCheck // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufApiversionCheck
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufApiversionCheck
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufApiversionCheck: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck] = [
+      .noneProtobufApiversionCheck,
+    ]
+
+  }
+
+  enum ProtobufAPIVersion_3: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufApiversion3 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufApiversion3
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufApiversion3
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufApiversion3: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_3] = [
+      .noneProtobufApiversion3,
+    ]
+
+  }
+
+  enum ProtobufBool: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufBool // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufBool
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufBool
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufBool: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBool] = [
+      .noneProtobufBool,
+    ]
+
+  }
+
+  enum ProtobufBytes: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufBytes // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufBytes
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufBytes
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufBytes: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBytes] = [
+      .noneProtobufBytes,
+    ]
+
+  }
+
+  enum ProtobufDouble: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufDouble // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufDouble
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufDouble
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufDouble: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufDouble] = [
+      .noneProtobufDouble,
+    ]
+
+  }
+
+  enum ProtobufEnumMap: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufEnumMap // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufEnumMap
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufEnumMap
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufEnumMap: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufEnumMap] = [
+      .noneProtobufEnumMap,
+    ]
+
+  }
+
+  enum protobufExtension: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufExtension // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufExtension
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufExtension
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufExtension: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufExtension] = [
+      .noneProtobufExtension,
+    ]
+
+  }
+
+  enum ProtobufFixed32: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufFixed32 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufFixed32
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufFixed32
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufFixed32: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed32] = [
+      .noneProtobufFixed32,
+    ]
+
+  }
+
+  enum ProtobufFixed64: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufFixed64 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufFixed64
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufFixed64
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufFixed64: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed64] = [
+      .noneProtobufFixed64,
+    ]
+
+  }
+
+  enum ProtobufFloat: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufFloat // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufFloat
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufFloat
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufFloat: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFloat] = [
+      .noneProtobufFloat,
+    ]
+
+  }
+
+  enum ProtobufInt32: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufInt32 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufInt32
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufInt32
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufInt32: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt32] = [
+      .noneProtobufInt32,
+    ]
+
+  }
+
+  enum ProtobufInt64: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufInt64 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufInt64
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufInt64
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufInt64: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt64] = [
+      .noneProtobufInt64,
+    ]
+
+  }
+
+  enum ProtobufMap: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufMap // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufMap
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufMap
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufMap: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMap] = [
+      .noneProtobufMap,
+    ]
+
+  }
+
+  enum ProtobufMessageMap: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufMessageMap // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufMessageMap
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufMessageMap
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufMessageMap: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMessageMap] = [
+      .noneProtobufMessageMap,
+    ]
+
+  }
+
+  enum ProtobufSFixed32: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufSfixed32 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufSfixed32
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufSfixed32
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufSfixed32: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed32] = [
+      .noneProtobufSfixed32,
+    ]
+
+  }
+
+  enum ProtobufSFixed64: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufSfixed64 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufSfixed64
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufSfixed64
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufSfixed64: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed64] = [
+      .noneProtobufSfixed64,
+    ]
+
+  }
+
+  enum ProtobufSInt32: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufSint32 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufSint32
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufSint32
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufSint32: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt32] = [
+      .noneProtobufSint32,
+    ]
+
+  }
+
+  enum ProtobufSInt64: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufSint64 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufSint64
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufSint64
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufSint64: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt64] = [
+      .noneProtobufSint64,
+    ]
+
+  }
+
+  enum ProtobufString: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufString // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufString
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufString
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufString: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufString] = [
+      .noneProtobufString,
+    ]
+
+  }
+
+  enum ProtobufUInt32: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufUint32 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufUint32
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufUint32
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufUint32: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt32] = [
+      .noneProtobufUint32,
+    ]
+
+  }
+
+  enum ProtobufUInt64: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufUint64 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufUint64
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufUint64
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufUint64: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt64] = [
+      .noneProtobufUint64,
+    ]
+
+  }
+
+  enum protobuf_extensionFieldValues: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufExtensionFieldValues // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufExtensionFieldValues
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufExtensionFieldValues
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufExtensionFieldValues: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues] = [
+      .noneProtobufExtensionFieldValues,
+    ]
+
+  }
+
+  enum protobuf_fieldNumber: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufFieldNumber // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufFieldNumber
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufFieldNumber
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufFieldNumber: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_fieldNumber] = [
+      .noneProtobufFieldNumber,
+    ]
+
+  }
+
+  enum protobuf_generated_isEqualTo: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufGeneratedIsEqualTo // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufGeneratedIsEqualTo
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufGeneratedIsEqualTo
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufGeneratedIsEqualTo: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo] = [
+      .noneProtobufGeneratedIsEqualTo,
+    ]
+
+  }
+
+  enum protobuf_nameMap: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufNameMap // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufNameMap
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufNameMap
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufNameMap: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_nameMap] = [
+      .noneProtobufNameMap,
+    ]
+
+  }
+
+  enum protobuf_newField: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufNewField // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufNewField
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufNewField
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufNewField: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_newField] = [
+      .noneProtobufNewField,
+    ]
+
+  }
+
+  enum protobuf_package: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtobufPackage // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtobufPackage
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtobufPackage
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtobufPackage: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_package] = [
+      .noneProtobufPackage,
+    ]
+
+  }
+
+  enum protocolEnum: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtocol // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtocol
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtocol
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtocol: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protocolEnum] = [
+      .noneProtocol,
+    ]
+
+  }
+
+  enum protoFieldName: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtoFieldName // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtoFieldName
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtoFieldName
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtoFieldName: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoFieldName] = [
+      .noneProtoFieldName,
+    ]
+
+  }
+
+  enum protoMessageNameEnum: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtoMessageName // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtoMessageName
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtoMessageName
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtoMessageName: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoMessageNameEnum] = [
+      .noneProtoMessageName,
+    ]
+
+  }
+
+  enum ProtoNameProviding: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtoNameProviding // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtoNameProviding
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtoNameProviding
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtoNameProviding: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtoNameProviding] = [
+      .noneProtoNameProviding,
+    ]
+
+  }
+
+  enum protoPaths: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneProtoPaths // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneProtoPaths
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneProtoPaths
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneProtoPaths: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoPaths] = [
+      .noneProtoPaths,
+    ]
+
+  }
+
+  enum publicEnum: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePublic // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePublic
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePublic
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePublic: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicEnum] = [
+      .nonePublic,
+    ]
+
+  }
+
+  enum publicDependency: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePublicDependency // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePublicDependency
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePublicDependency
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePublicDependency: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicDependency] = [
+      .nonePublicDependency,
+    ]
+
+  }
+
+  enum putBoolValue: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutBoolValue // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutBoolValue
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutBoolValue
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutBoolValue: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBoolValue] = [
+      .nonePutBoolValue,
+    ]
+
+  }
+
+  enum putBytesValue: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutBytesValue // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutBytesValue
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutBytesValue
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutBytesValue: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBytesValue] = [
+      .nonePutBytesValue,
+    ]
+
+  }
+
+  enum putDoubleValue: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutDoubleValue // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutDoubleValue
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutDoubleValue
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutDoubleValue: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putDoubleValue] = [
+      .nonePutDoubleValue,
+    ]
+
+  }
+
+  enum putEnumValue: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutEnumValue // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutEnumValue
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutEnumValue
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutEnumValue: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putEnumValue] = [
+      .nonePutEnumValue,
+    ]
+
+  }
+
+  enum putFixedUInt32: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutFixedUint32 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutFixedUint32
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutFixedUint32
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutFixedUint32: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt32] = [
+      .nonePutFixedUint32,
+    ]
+
+  }
+
+  enum putFixedUInt64: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutFixedUint64 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutFixedUint64
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutFixedUint64
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutFixedUint64: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt64] = [
+      .nonePutFixedUint64,
+    ]
+
+  }
+
+  enum putFloatValue: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutFloatValue // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutFloatValue
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutFloatValue
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutFloatValue: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFloatValue] = [
+      .nonePutFloatValue,
+    ]
+
+  }
+
+  enum putInt64: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutInt64 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutInt64
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutInt64
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutInt64: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putInt64] = [
+      .nonePutInt64,
+    ]
+
+  }
+
+  enum putStringValue: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutStringValue // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutStringValue
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutStringValue
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutStringValue: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putStringValue] = [
+      .nonePutStringValue,
+    ]
+
+  }
+
+  enum putUInt64: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutUint64 // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutUint64
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutUint64
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutUint64: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64] = [
+      .nonePutUint64,
+    ]
+
+  }
+
+  enum putUInt64Hex: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutUint64Hex // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutUint64Hex
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutUint64Hex
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutUint64Hex: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64Hex] = [
+      .nonePutUint64Hex,
+    ]
+
+  }
+
+  enum putVarInt: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case nonePutVarInt // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .nonePutVarInt
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .nonePutVarInt
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .nonePutVarInt: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putVarInt] = [
+      .nonePutVarInt,
+    ]
+
+  }
+
+  enum putZigZagVarInt: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufInt32 // = 0
+    case nonePutZigZagVarInt // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufInt32
+      self = .nonePutZigZagVarInt
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufInt32
+      case 0: self = .nonePutZigZagVarInt
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufInt32: return 0
+      case .nonePutZigZagVarInt: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt32] = [
-      .noneProtobufInt32,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putZigZagVarInt] = [
+      .nonePutZigZagVarInt,
     ]
 
   }
 
-  enum ProtobufInt64: SwiftProtobuf.Enum {
+  enum pyGenericServices: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufInt64 // = 0
+    case nonePyGenericServices // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufInt64
+      self = .nonePyGenericServices
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufInt64
+      case 0: self = .nonePyGenericServices
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufInt64: return 0
+      case .nonePyGenericServices: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt64] = [
-      .noneProtobufInt64,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pyGenericServices] = [
+      .nonePyGenericServices,
     ]
 
   }
 
-  enum ProtobufMap: SwiftProtobuf.Enum {
+  enum R: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufMap // = 0
+    case noneR // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufMap
+      self = .noneR
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufMap
+      case 0: self = .noneR
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufMap: return 0
+      case .noneR: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMap] = [
-      .noneProtobufMap,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.R] = [
+      .noneR,
     ]
 
   }
 
-  enum ProtobufMessageMap: SwiftProtobuf.Enum {
+  enum rawChars: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufMessageMap // = 0
+    case noneRawChars // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufMessageMap
+      self = .noneRawChars
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufMessageMap
+      case 0: self = .noneRawChars
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufMessageMap: return 0
+      case .noneRawChars: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMessageMap] = [
-      .noneProtobufMessageMap,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rawChars] = [
+      .noneRawChars,
     ]
 
   }
 
-  enum ProtobufSFixed32: SwiftProtobuf.Enum {
+  enum RawRepresentable: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufSfixed32 // = 0
+    case noneRawRepresentable // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufSfixed32
+      self = .noneRawRepresentable
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufSfixed32
+      case 0: self = .noneRawRepresentable
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufSfixed32: return 0
+      case .noneRawRepresentable: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed32] = [
-      .noneProtobufSfixed32,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawRepresentable] = [
+      .noneRawRepresentable,
     ]
 
   }
 
-  enum ProtobufSFixed64: SwiftProtobuf.Enum {
+  enum RawValue: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufSfixed64 // = 0
+    case noneRawValue // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufSfixed64
+      self = .noneRawValue
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufSfixed64
+      case 0: self = .noneRawValue
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufSfixed64: return 0
+      case .noneRawValue: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed64] = [
-      .noneProtobufSfixed64,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawValue] = [
+      .noneRawValue,
     ]
 
   }
 
-  enum ProtobufSInt32: SwiftProtobuf.Enum {
+  enum read4HexDigits: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufSint32 // = 0
+    case noneRead4HexDigits // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufSint32
+      self = .noneRead4HexDigits
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufSint32
+      case 0: self = .noneRead4HexDigits
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufSint32: return 0
+      case .noneRead4HexDigits: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt32] = [
-      .noneProtobufSint32,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.read4HexDigits] = [
+      .noneRead4HexDigits,
     ]
 
   }
 
-  enum ProtobufSInt64: SwiftProtobuf.Enum {
+  enum readBytes: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufSint64 // = 0
+    case noneReadBytes // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufSint64
+      self = .noneReadBytes
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufSint64
+      case 0: self = .noneReadBytes
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufSint64: return 0
+      case .noneReadBytes: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt64] = [
-      .noneProtobufSint64,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.readBytes] = [
+      .noneReadBytes,
     ]
 
   }
 
-  enum ProtobufString: SwiftProtobuf.Enum {
+  enum register: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufString // = 0
+    case noneRegister // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufString
+      self = .noneRegister
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufString
+      case 0: self = .noneRegister
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufString: return 0
+      case .noneRegister: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufString] = [
-      .noneProtobufString,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.register] = [
+      .noneRegister,
     ]
 
   }
 
-  enum ProtobufUInt32: SwiftProtobuf.Enum {
+  enum repeated: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufUint32 // = 0
+    case noneRepeated // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufUint32
+      self = .noneRepeated
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufUint32
+      case 0: self = .noneRepeated
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufUint32: return 0
+      case .noneRepeated: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt32] = [
-      .noneProtobufUint32,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeated] = [
+      .noneRepeated,
     ]
 
   }
 
-  enum ProtobufUInt64: SwiftProtobuf.Enum {
+  enum repeatedBool: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufUint64 // = 0
+    case noneRepeatedBool // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufUint64
+      self = .noneRepeatedBool
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufUint64
+      case 0: self = .noneRepeatedBool
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufUint64: return 0
+      case .noneRepeatedBool: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt64] = [
-      .noneProtobufUint64,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedBool] = [
+      .noneRepeatedBool,
     ]
 
   }
 
-  enum protobuf_extensionFieldValues: SwiftProtobuf.Enum {
+  enum repeatedBytes: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufExtensionFieldValues // = 0
+    case noneRepeatedBytes // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufExtensionFieldValues
+      self = .noneRepeatedBytes
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufExtensionFieldValues
+      case 0: self = .noneRepeatedBytes
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufExtensionFieldValues: return 0
+      case .noneRepeatedBytes: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues] = [
-      .noneProtobufExtensionFieldValues,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedBytes] = [
+      .noneRepeatedBytes,
     ]
 
   }
 
-  enum protobuf_fieldNumber: SwiftProtobuf.Enum {
+  enum repeatedDouble: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufFieldNumber // = 0
+    case noneRepeatedDouble // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufFieldNumber
+      self = .noneRepeatedDouble
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufFieldNumber
+      case 0: self = .noneRepeatedDouble
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufFieldNumber: return 0
+      case .noneRepeatedDouble: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_fieldNumber] = [
-      .noneProtobufFieldNumber,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedDouble] = [
+      .noneRepeatedDouble,
     ]
 
   }
 
-  enum protobuf_generated_isEqualTo: SwiftProtobuf.Enum {
+  enum repeatedEnum: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufGeneratedIsEqualTo // = 0
+    case noneRepeatedEnum // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufGeneratedIsEqualTo
+      self = .noneRepeatedEnum
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufGeneratedIsEqualTo
+      case 0: self = .noneRepeatedEnum
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufGeneratedIsEqualTo: return 0
+      case .noneRepeatedEnum: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo] = [
-      .noneProtobufGeneratedIsEqualTo,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedEnum] = [
+      .noneRepeatedEnum,
     ]
 
   }
 
-  enum protobuf_nameMap: SwiftProtobuf.Enum {
+  enum RepeatedEnumExtensionField: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufNameMap // = 0
+    case noneRepeatedEnumExtensionField // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufNameMap
+      self = .noneRepeatedEnumExtensionField
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufNameMap
+      case 0: self = .noneRepeatedEnumExtensionField
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufNameMap: return 0
+      case .noneRepeatedEnumExtensionField: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_nameMap] = [
-      .noneProtobufNameMap,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField] = [
+      .noneRepeatedEnumExtensionField,
     ]
 
   }
 
-  enum protobuf_newField: SwiftProtobuf.Enum {
+  enum RepeatedExtensionField: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufNewField // = 0
+    case noneRepeatedExtensionField // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufNewField
+      self = .noneRepeatedExtensionField
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufNewField
+      case 0: self = .noneRepeatedExtensionField
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufNewField: return 0
+      case .noneRepeatedExtensionField: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_newField] = [
-      .noneProtobufNewField,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedExtensionField] = [
+      .noneRepeatedExtensionField,
     ]
 
   }
 
-  enum protobuf_package: SwiftProtobuf.Enum {
+  enum repeatedFieldEncoding: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtobufPackage // = 0
+    case noneRepeatedFieldEncoding // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtobufPackage
+      self = .noneRepeatedFieldEncoding
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtobufPackage
+      case 0: self = .noneRepeatedFieldEncoding
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtobufPackage: return 0
+      case .noneRepeatedFieldEncoding: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_package] = [
-      .noneProtobufPackage,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFieldEncoding] = [
+      .noneRepeatedFieldEncoding,
     ]
 
   }
 
-  enum protocolEnum: SwiftProtobuf.Enum {
+  enum repeatedFixed32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtocol // = 0
+    case noneRepeatedFixed32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtocol
+      self = .noneRepeatedFixed32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtocol
+      case 0: self = .noneRepeatedFixed32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtocol: return 0
+      case .noneRepeatedFixed32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protocolEnum] = [
-      .noneProtocol,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFixed32] = [
+      .noneRepeatedFixed32,
     ]
 
   }
 
-  enum protoFieldName: SwiftProtobuf.Enum {
+  enum repeatedFixed64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtoFieldName // = 0
+    case noneRepeatedFixed64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtoFieldName
+      self = .noneRepeatedFixed64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtoFieldName
+      case 0: self = .noneRepeatedFixed64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtoFieldName: return 0
+      case .noneRepeatedFixed64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoFieldName] = [
-      .noneProtoFieldName,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFixed64] = [
+      .noneRepeatedFixed64,
     ]
 
   }
 
-  enum protoMessageNameEnum: SwiftProtobuf.Enum {
+  enum repeatedFloat: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtoMessageName // = 0
+    case noneRepeatedFloat // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtoMessageName
+      self = .noneRepeatedFloat
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtoMessageName
+      case 0: self = .noneRepeatedFloat
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtoMessageName: return 0
+      case .noneRepeatedFloat: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoMessageNameEnum] = [
-      .noneProtoMessageName,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFloat] = [
+      .noneRepeatedFloat,
     ]
 
   }
 
-  enum ProtoNameProviding: SwiftProtobuf.Enum {
+  enum repeatedGroup: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtoNameProviding // = 0
+    case noneRepeatedGroup // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtoNameProviding
+      self = .noneRepeatedGroup
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtoNameProviding
+      case 0: self = .noneRepeatedGroup
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtoNameProviding: return 0
+      case .noneRepeatedGroup: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtoNameProviding] = [
-      .noneProtoNameProviding,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedGroup] = [
+      .noneRepeatedGroup,
     ]
 
   }
 
-  enum protoPaths: SwiftProtobuf.Enum {
+  enum RepeatedGroupExtensionField: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneProtoPaths // = 0
+    case noneRepeatedGroupExtensionField // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneProtoPaths
+      self = .noneRepeatedGroupExtensionField
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneProtoPaths
+      case 0: self = .noneRepeatedGroupExtensionField
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneProtoPaths: return 0
+      case .noneRepeatedGroupExtensionField: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoPaths] = [
-      .noneProtoPaths,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField] = [
+      .noneRepeatedGroupExtensionField,
     ]
 
   }
 
-  enum publicEnum: SwiftProtobuf.Enum {
+  enum repeatedInt32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePublic // = 0
+    case noneRepeatedInt32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePublic
+      self = .noneRepeatedInt32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePublic
+      case 0: self = .noneRepeatedInt32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePublic: return 0
+      case .noneRepeatedInt32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicEnum] = [
-      .nonePublic,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedInt32] = [
+      .noneRepeatedInt32,
     ]
 
   }
 
-  enum publicDependency: SwiftProtobuf.Enum {
+  enum repeatedInt64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePublicDependency // = 0
+    case noneRepeatedInt64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePublicDependency
+      self = .noneRepeatedInt64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePublicDependency
+      case 0: self = .noneRepeatedInt64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePublicDependency: return 0
+      case .noneRepeatedInt64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicDependency] = [
-      .nonePublicDependency,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedInt64] = [
+      .noneRepeatedInt64,
     ]
 
   }
 
-  enum putBoolValue: SwiftProtobuf.Enum {
+  enum repeatedMessage: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutBoolValue // = 0
+    case noneRepeatedMessage // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutBoolValue
+      self = .noneRepeatedMessage
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutBoolValue
+      case 0: self = .noneRepeatedMessage
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutBoolValue: return 0
+      case .noneRepeatedMessage: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBoolValue] = [
-      .nonePutBoolValue,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedMessage] = [
+      .noneRepeatedMessage,
     ]
 
   }
 
-  enum putBytesValue: SwiftProtobuf.Enum {
+  enum RepeatedMessageExtensionField: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutBytesValue // = 0
+    case noneRepeatedMessageExtensionField // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutBytesValue
+      self = .noneRepeatedMessageExtensionField
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutBytesValue
+      case 0: self = .noneRepeatedMessageExtensionField
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutBytesValue: return 0
+      case .noneRepeatedMessageExtensionField: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBytesValue] = [
-      .nonePutBytesValue,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField] = [
+      .noneRepeatedMessageExtensionField,
     ]
 
   }
 
-  enum putDoubleValue: SwiftProtobuf.Enum {
+  enum repeatedSFixed32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutDoubleValue // = 0
+    case noneRepeatedSfixed32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutDoubleValue
+      self = .noneRepeatedSfixed32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutDoubleValue
+      case 0: self = .noneRepeatedSfixed32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutDoubleValue: return 0
+      case .noneRepeatedSfixed32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putDoubleValue] = [
-      .nonePutDoubleValue,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedSFixed32] = [
+      .noneRepeatedSfixed32,
     ]
 
   }
 
-  enum putEnumValue: SwiftProtobuf.Enum {
+  enum repeatedSFixed64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutEnumValue // = 0
+    case noneRepeatedSfixed64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutEnumValue
+      self = .noneRepeatedSfixed64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutEnumValue
+      case 0: self = .noneRepeatedSfixed64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutEnumValue: return 0
+      case .noneRepeatedSfixed64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putEnumValue] = [
-      .nonePutEnumValue,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedSFixed64] = [
+      .noneRepeatedSfixed64,
     ]
 
   }
 
-  enum putFixedUInt32: SwiftProtobuf.Enum {
+  enum repeatedSInt32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutFixedUint32 // = 0
+    case noneRepeatedSint32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutFixedUint32
+      self = .noneRepeatedSint32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutFixedUint32
+      case 0: self = .noneRepeatedSint32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutFixedUint32: return 0
+      case .noneRepeatedSint32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt32] = [
-      .nonePutFixedUint32,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedSInt32] = [
+      .noneRepeatedSint32,
     ]
 
   }
 
-  enum putFixedUInt64: SwiftProtobuf.Enum {
+  enum repeatedSInt64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutFixedUint64 // = 0
+    case noneRepeatedSint64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutFixedUint64
+      self = .noneRepeatedSint64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutFixedUint64
+      case 0: self = .noneRepeatedSint64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutFixedUint64: return 0
+      case .noneRepeatedSint64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt64] = [
-      .nonePutFixedUint64,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedSInt64] = [
+      .noneRepeatedSint64,
     ]
 
   }
 
-  enum putFloatValue: SwiftProtobuf.Enum {
+  enum repeatedString: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutFloatValue // = 0
+    case noneRepeatedString // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutFloatValue
+      self = .noneRepeatedString
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutFloatValue
+      case 0: self = .noneRepeatedString
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutFloatValue: return 0
+      case .noneRepeatedString: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFloatValue] = [
-      .nonePutFloatValue,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedString] = [
+      .noneRepeatedString,
     ]
 
   }
 
-  enum putInt64: SwiftProtobuf.Enum {
+  enum repeatedUInt32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutInt64 // = 0
+    case noneRepeatedUint32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutInt64
+      self = .noneRepeatedUint32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutInt64
+      case 0: self = .noneRepeatedUint32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutInt64: return 0
+      case .noneRepeatedUint32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putInt64] = [
-      .nonePutInt64,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedUInt32] = [
+      .noneRepeatedUint32,
     ]
 
   }
 
-  enum putStringValue: SwiftProtobuf.Enum {
+  enum repeatedUInt64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutStringValue // = 0
+    case noneRepeatedUint64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutStringValue
+      self = .noneRepeatedUint64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutStringValue
+      case 0: self = .noneRepeatedUint64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutStringValue: return 0
+      case .noneRepeatedUint64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putStringValue] = [
-      .nonePutStringValue,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedUInt64] = [
+      .noneRepeatedUint64,
     ]
 
   }
 
-  enum putUInt64: SwiftProtobuf.Enum {
+  enum repeating: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutUint64 // = 0
+    case noneRepeating // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutUint64
+      self = .noneRepeating
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutUint64
+      case 0: self = .noneRepeating
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutUint64: return 0
+      case .noneRepeating: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64] = [
-      .nonePutUint64,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeating] = [
+      .noneRepeating,
     ]
 
   }
 
-  enum putUInt64Hex: SwiftProtobuf.Enum {
+  enum requestStreaming: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutUint64Hex // = 0
+    case noneRequestStreaming // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutUint64Hex
+      self = .noneRequestStreaming
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutUint64Hex
+      case 0: self = .noneRequestStreaming
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutUint64Hex: return 0
+      case .noneRequestStreaming: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64Hex] = [
-      .nonePutUint64Hex,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestStreaming] = [
+      .noneRequestStreaming,
     ]
 
   }
 
-  enum putVarInt: SwiftProtobuf.Enum {
+  enum requestTypeURL: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutVarInt // = 0
+    case noneRequestTypeURL // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutVarInt
+      self = .noneRequestTypeURL
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutVarInt
+      case 0: self = .noneRequestTypeURL
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutVarInt: return 0
+      case .noneRequestTypeURL: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putVarInt] = [
-      .nonePutVarInt,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestTypeURL] = [
+      .noneRequestTypeURL,
     ]
 
   }
 
-  enum putZigZagVarInt: SwiftProtobuf.Enum {
+  enum requiredSize: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePutZigZagVarInt // = 0
+    case noneRequiredSize // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePutZigZagVarInt
+      self = .noneRequiredSize
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePutZigZagVarInt
+      case 0: self = .noneRequiredSize
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePutZigZagVarInt: return 0
+      case .noneRequiredSize: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putZigZagVarInt] = [
-      .nonePutZigZagVarInt,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requiredSize] = [
+      .noneRequiredSize,
     ]
 
   }
 
-  enum pyGenericServices: SwiftProtobuf.Enum {
+  enum responseStreaming: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case nonePyGenericServices // = 0
+    case noneResponseStreaming // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .nonePyGenericServices
+      self = .noneResponseStreaming
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .nonePyGenericServices
+      case 0: self = .noneResponseStreaming
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .nonePyGenericServices: return 0
+      case .noneResponseStreaming: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pyGenericServices] = [
-      .nonePyGenericServices,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseStreaming] = [
+      .noneResponseStreaming,
     ]
 
   }
 
-  enum R: SwiftProtobuf.Enum {
+  enum responseTypeURL: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneR // = 0
+    case noneResponseTypeURL // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneR
+      self = .noneResponseTypeURL
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneR
+      case 0: self = .noneResponseTypeURL
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneR: return 0
+      case .noneResponseTypeURL: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.R] = [
-      .noneR,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseTypeURL] = [
+      .noneResponseTypeURL,
     ]
 
   }
 
-  enum rawChars: SwiftProtobuf.Enum {
+  enum result: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRawChars // = 0
+    case noneResult // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRawChars
+      self = .noneResult
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRawChars
+      case 0: self = .noneResult
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRawChars: return 0
+      case .noneResult: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rawChars] = [
-      .noneRawChars,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.result] = [
+      .noneResult,
     ]
 
   }
 
-  enum RawRepresentable: SwiftProtobuf.Enum {
+  enum retention: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRawRepresentable // = 0
+    case noneRetention // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRawRepresentable
+      self = .noneRetention
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRawRepresentable
+      case 0: self = .noneRetention
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRawRepresentable: return 0
+      case .noneRetention: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawRepresentable] = [
-      .noneRawRepresentable,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.retention] = [
+      .noneRetention,
     ]
 
   }
 
-  enum RawValue: SwiftProtobuf.Enum {
+  enum rethrowsEnum: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRawValue // = 0
+    case noneRethrows // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRawValue
+      self = .noneRethrows
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRawValue
+      case 0: self = .noneRethrows
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRawValue: return 0
+      case .noneRethrows: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawValue] = [
-      .noneRawValue,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rethrowsEnum] = [
+      .noneRethrows,
     ]
 
   }
 
-  enum read4HexDigits: SwiftProtobuf.Enum {
+  enum returnEnum: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRead4HexDigits // = 0
+    case noneReturn // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRead4HexDigits
+      self = .noneReturn
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRead4HexDigits
+      case 0: self = .noneReturn
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRead4HexDigits: return 0
+      case .noneReturn: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.read4HexDigits] = [
-      .noneRead4HexDigits,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.returnEnum] = [
+      .noneReturn,
     ]
 
   }
 
-  enum readBytes: SwiftProtobuf.Enum {
+  enum ReturnType: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneReadBytes // = 0
+    case noneReturnType // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneReadBytes
+      self = .noneReturnType
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneReadBytes
+      case 0: self = .noneReturnType
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneReadBytes: return 0
+      case .noneReturnType: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.readBytes] = [
-      .noneReadBytes,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ReturnType] = [
+      .noneReturnType,
     ]
 
   }
 
-  enum register: SwiftProtobuf.Enum {
+  enum revision: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRegister // = 0
+    case noneRevision // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRegister
+      self = .noneRevision
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRegister
+      case 0: self = .noneRevision
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRegister: return 0
+      case .noneRevision: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.register] = [
-      .noneRegister,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.revision] = [
+      .noneRevision,
     ]
 
   }
 
-  enum repeated: SwiftProtobuf.Enum {
+  enum rhs: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRepeated // = 0
+    case noneRhs // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRepeated
+      self = .noneRhs
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRepeated
+      case 0: self = .noneRhs
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRepeated: return 0
+      case .noneRhs: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeated] = [
-      .noneRepeated,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rhs] = [
+      .noneRhs,
     ]
 
   }
 
-  enum RepeatedEnumExtensionField: SwiftProtobuf.Enum {
+  enum root: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRepeatedEnumExtensionField // = 0
+    case noneRoot // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRepeatedEnumExtensionField
+      self = .noneRoot
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRepeatedEnumExtensionField
+      case 0: self = .noneRoot
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRepeatedEnumExtensionField: return 0
+      case .noneRoot: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField] = [
-      .noneRepeatedEnumExtensionField,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.root] = [
+      .noneRoot,
     ]
 
   }
 
-  enum RepeatedExtensionField: SwiftProtobuf.Enum {
+  enum rubyPackage: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRepeatedExtensionField // = 0
+    case noneRubyPackage // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRepeatedExtensionField
+      self = .noneRubyPackage
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRepeatedExtensionField
+      case 0: self = .noneRubyPackage
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRepeatedExtensionField: return 0
+      case .noneRubyPackage: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedExtensionField] = [
-      .noneRepeatedExtensionField,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rubyPackage] = [
+      .noneRubyPackage,
     ]
 
   }
 
-  enum repeatedFieldEncoding: SwiftProtobuf.Enum {
+  enum s: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRepeatedFieldEncoding // = 0
+    case noneS // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRepeatedFieldEncoding
+      self = .noneS
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRepeatedFieldEncoding
+      case 0: self = .noneS
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRepeatedFieldEncoding: return 0
+      case .noneS: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFieldEncoding] = [
-      .noneRepeatedFieldEncoding,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.s] = [
+      .noneS,
     ]
 
   }
 
-  enum RepeatedGroupExtensionField: SwiftProtobuf.Enum {
+  enum sawBackslash: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRepeatedGroupExtensionField // = 0
+    case noneSawBackslash // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRepeatedGroupExtensionField
+      self = .noneSawBackslash
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRepeatedGroupExtensionField
+      case 0: self = .noneSawBackslash
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRepeatedGroupExtensionField: return 0
+      case .noneSawBackslash: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField] = [
-      .noneRepeatedGroupExtensionField,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawBackslash] = [
+      .noneSawBackslash,
     ]
 
   }
 
-  enum RepeatedMessageExtensionField: SwiftProtobuf.Enum {
+  enum sawSection4Characters: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRepeatedMessageExtensionField // = 0
+    case noneSawSection4Characters // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRepeatedMessageExtensionField
+      self = .noneSawSection4Characters
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRepeatedMessageExtensionField
+      case 0: self = .noneSawSection4Characters
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRepeatedMessageExtensionField: return 0
+      case .noneSawSection4Characters: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField] = [
-      .noneRepeatedMessageExtensionField,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection4Characters] = [
+      .noneSawSection4Characters,
     ]
 
   }
 
-  enum repeating: SwiftProtobuf.Enum {
+  enum sawSection5Characters: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRepeating // = 0
+    case noneSawSection5Characters // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRepeating
+      self = .noneSawSection5Characters
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRepeating
+      case 0: self = .noneSawSection5Characters
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRepeating: return 0
+      case .noneSawSection5Characters: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeating] = [
-      .noneRepeating,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection5Characters] = [
+      .noneSawSection5Characters,
     ]
 
   }
 
-  enum requestStreaming: SwiftProtobuf.Enum {
+  enum scanner: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRequestStreaming // = 0
+    case noneScanner // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRequestStreaming
+      self = .noneScanner
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRequestStreaming
+      case 0: self = .noneScanner
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRequestStreaming: return 0
+      case .noneScanner: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestStreaming] = [
-      .noneRequestStreaming,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scanner] = [
+      .noneScanner,
     ]
 
   }
 
-  enum requestTypeURL: SwiftProtobuf.Enum {
+  enum seconds: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRequestTypeURL // = 0
+    case noneSeconds // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRequestTypeURL
+      self = .noneSeconds
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRequestTypeURL
+      case 0: self = .noneSeconds
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRequestTypeURL: return 0
+      case .noneSeconds: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestTypeURL] = [
-      .noneRequestTypeURL,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.seconds] = [
+      .noneSeconds,
     ]
 
   }
 
-  enum requiredSize: SwiftProtobuf.Enum {
+  enum selfEnum: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRequiredSize // = 0
+    case noneSelf // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRequiredSize
+      self = .noneSelf
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRequiredSize
+      case 0: self = .noneSelf
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRequiredSize: return 0
+      case .noneSelf: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requiredSize] = [
-      .noneRequiredSize,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.selfEnum] = [
+      .noneSelf,
     ]
 
   }
 
-  enum responseStreaming: SwiftProtobuf.Enum {
+  enum semantic: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneResponseStreaming // = 0
+    case noneSemantic // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneResponseStreaming
+      self = .noneSemantic
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneResponseStreaming
+      case 0: self = .noneSemantic
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneResponseStreaming: return 0
+      case .noneSemantic: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseStreaming] = [
-      .noneResponseStreaming,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.semantic] = [
+      .noneSemantic,
     ]
 
   }
 
-  enum responseTypeURL: SwiftProtobuf.Enum {
+  enum SendableEnum: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneResponseTypeURL // = 0
+    case noneSendable // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneResponseTypeURL
+      self = .noneSendable
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneResponseTypeURL
+      case 0: self = .noneSendable
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneResponseTypeURL: return 0
+      case .noneSendable: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseTypeURL] = [
-      .noneResponseTypeURL,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SendableEnum] = [
+      .noneSendable,
     ]
 
   }
 
-  enum result: SwiftProtobuf.Enum {
+  enum separator: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneResult // = 0
+    case noneSeparator // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneResult
+      self = .noneSeparator
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneResult
+      case 0: self = .noneSeparator
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneResult: return 0
+      case .noneSeparator: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.result] = [
-      .noneResult,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.separator] = [
+      .noneSeparator,
     ]
 
   }
 
-  enum retention: SwiftProtobuf.Enum {
+  enum serialize: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRetention // = 0
+    case noneSerialize // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRetention
+      self = .noneSerialize
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRetention
+      case 0: self = .noneSerialize
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRetention: return 0
+      case .noneSerialize: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.retention] = [
-      .noneRetention,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serialize] = [
+      .noneSerialize,
     ]
 
   }
 
-  enum rethrowsEnum: SwiftProtobuf.Enum {
+  enum serializedBytes: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRethrows // = 0
+    case noneSerializedBytes // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRethrows
+      self = .noneSerializedBytes
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRethrows
+      case 0: self = .noneSerializedBytes
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRethrows: return 0
+      case .noneSerializedBytes: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rethrowsEnum] = [
-      .noneRethrows,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedBytes] = [
+      .noneSerializedBytes,
     ]
 
   }
 
-  enum returnEnum: SwiftProtobuf.Enum {
+  enum serializedData: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneReturn // = 0
+    case noneSerializedData // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneReturn
+      self = .noneSerializedData
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneReturn
+      case 0: self = .noneSerializedData
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneReturn: return 0
+      case .noneSerializedData: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.returnEnum] = [
-      .noneReturn,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedData] = [
+      .noneSerializedData,
     ]
 
   }
 
-  enum ReturnType: SwiftProtobuf.Enum {
+  enum serializedSize: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneReturnType // = 0
+    case noneSerializedSize // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneReturnType
+      self = .noneSerializedSize
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneReturnType
+      case 0: self = .noneSerializedSize
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneReturnType: return 0
+      case .noneSerializedSize: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ReturnType] = [
-      .noneReturnType,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedSize] = [
+      .noneSerializedSize,
     ]
 
   }
 
-  enum revision: SwiftProtobuf.Enum {
+  enum serverStreaming: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRevision // = 0
+    case noneServerStreaming // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRevision
+      self = .noneServerStreaming
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRevision
+      case 0: self = .noneServerStreaming
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRevision: return 0
+      case .noneServerStreaming: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.revision] = [
-      .noneRevision,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serverStreaming] = [
+      .noneServerStreaming,
     ]
 
   }
 
-  enum rhs: SwiftProtobuf.Enum {
+  enum service: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRhs // = 0
+    case noneService // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRhs
+      self = .noneService
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRhs
+      case 0: self = .noneService
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRhs: return 0
+      case .noneService: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rhs] = [
-      .noneRhs,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.service] = [
+      .noneService,
     ]
 
   }
 
-  enum root: SwiftProtobuf.Enum {
+  enum ServiceDescriptorProto: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRoot // = 0
+    case noneServiceDescriptorProto // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRoot
+      self = .noneServiceDescriptorProto
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRoot
+      case 0: self = .noneServiceDescriptorProto
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRoot: return 0
+      case .noneServiceDescriptorProto: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.root] = [
-      .noneRoot,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ServiceDescriptorProto] = [
+      .noneServiceDescriptorProto,
     ]
 
   }
 
-  enum rubyPackage: SwiftProtobuf.Enum {
+  enum ServiceOptions: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneRubyPackage // = 0
+    case noneServiceOptions // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneRubyPackage
+      self = .noneServiceOptions
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneRubyPackage
+      case 0: self = .noneServiceOptions
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneRubyPackage: return 0
+      case .noneServiceOptions: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rubyPackage] = [
-      .noneRubyPackage,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ServiceOptions] = [
+      .noneServiceOptions,
     ]
 
   }
 
-  enum s: SwiftProtobuf.Enum {
+  enum set: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneS // = 0
+    case noneSet // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneS
+      self = .noneSet
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneS
+      case 0: self = .noneSet
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneS: return 0
+      case .noneSet: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.s] = [
-      .noneS,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.set] = [
+      .noneSet,
     ]
 
   }
 
-  enum sawBackslash: SwiftProtobuf.Enum {
+  enum setExtensionValue: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSawBackslash // = 0
+    case noneSetExtensionValue // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSawBackslash
+      self = .noneSetExtensionValue
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSawBackslash
+      case 0: self = .noneSetExtensionValue
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSawBackslash: return 0
+      case .noneSetExtensionValue: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawBackslash] = [
-      .noneSawBackslash,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.setExtensionValue] = [
+      .noneSetExtensionValue,
     ]
 
   }
 
-  enum sawSection4Characters: SwiftProtobuf.Enum {
+  enum shift: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSawSection4Characters // = 0
+    case noneShift // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSawSection4Characters
+      self = .noneShift
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSawSection4Characters
+      case 0: self = .noneShift
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSawSection4Characters: return 0
+      case .noneShift: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection4Characters] = [
-      .noneSawSection4Characters,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.shift] = [
+      .noneShift,
     ]
 
   }
 
-  enum sawSection5Characters: SwiftProtobuf.Enum {
+  enum SimpleExtensionMap: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSawSection5Characters // = 0
+    case noneSimpleExtensionMap // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSawSection5Characters
+      self = .noneSimpleExtensionMap
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSawSection5Characters
+      case 0: self = .noneSimpleExtensionMap
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSawSection5Characters: return 0
+      case .noneSimpleExtensionMap: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection5Characters] = [
-      .noneSawSection5Characters,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SimpleExtensionMap] = [
+      .noneSimpleExtensionMap,
     ]
 
   }
 
-  enum scanner: SwiftProtobuf.Enum {
+  enum singularBool: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneScanner // = 0
+    case noneSingularBool // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneScanner
+      self = .noneSingularBool
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneScanner
+      case 0: self = .noneSingularBool
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneScanner: return 0
+      case .noneSingularBool: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scanner] = [
-      .noneScanner,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularBool] = [
+      .noneSingularBool,
     ]
 
   }
 
-  enum seconds: SwiftProtobuf.Enum {
+  enum singularBytes: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSeconds // = 0
+    case noneSingularBytes // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSeconds
+      self = .noneSingularBytes
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSeconds
+      case 0: self = .noneSingularBytes
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSeconds: return 0
+      case .noneSingularBytes: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.seconds] = [
-      .noneSeconds,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularBytes] = [
+      .noneSingularBytes,
     ]
 
   }
 
-  enum selfEnum: SwiftProtobuf.Enum {
+  enum singularDouble: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSelf // = 0
+    case noneSingularDouble // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSelf
+      self = .noneSingularDouble
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSelf
+      case 0: self = .noneSingularDouble
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSelf: return 0
+      case .noneSingularDouble: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.selfEnum] = [
-      .noneSelf,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularDouble] = [
+      .noneSingularDouble,
     ]
 
   }
 
-  enum semantic: SwiftProtobuf.Enum {
+  enum singularEnum: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSemantic // = 0
+    case noneSingularEnum // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSemantic
+      self = .noneSingularEnum
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSemantic
+      case 0: self = .noneSingularEnum
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSemantic: return 0
+      case .noneSingularEnum: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.semantic] = [
-      .noneSemantic,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularEnum] = [
+      .noneSingularEnum,
     ]
 
   }
 
-  enum SendableEnum: SwiftProtobuf.Enum {
+  enum singularFixed32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSendable // = 0
+    case noneSingularFixed32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSendable
+      self = .noneSingularFixed32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSendable
+      case 0: self = .noneSingularFixed32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSendable: return 0
+      case .noneSingularFixed32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SendableEnum] = [
-      .noneSendable,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularFixed32] = [
+      .noneSingularFixed32,
     ]
 
   }
 
-  enum separator: SwiftProtobuf.Enum {
+  enum singularFixed64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSeparator // = 0
+    case noneSingularFixed64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSeparator
+      self = .noneSingularFixed64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSeparator
+      case 0: self = .noneSingularFixed64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSeparator: return 0
+      case .noneSingularFixed64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.separator] = [
-      .noneSeparator,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularFixed64] = [
+      .noneSingularFixed64,
     ]
 
   }
 
-  enum serialize: SwiftProtobuf.Enum {
+  enum singularFloat: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSerialize // = 0
+    case noneSingularFloat // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSerialize
+      self = .noneSingularFloat
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSerialize
+      case 0: self = .noneSingularFloat
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSerialize: return 0
+      case .noneSingularFloat: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serialize] = [
-      .noneSerialize,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularFloat] = [
+      .noneSingularFloat,
     ]
 
   }
 
-  enum serializedBytes: SwiftProtobuf.Enum {
+  enum singularGroup: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSerializedBytes // = 0
+    case noneSingularGroup // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSerializedBytes
+      self = .noneSingularGroup
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSerializedBytes
+      case 0: self = .noneSingularGroup
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSerializedBytes: return 0
+      case .noneSingularGroup: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedBytes] = [
-      .noneSerializedBytes,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularGroup] = [
+      .noneSingularGroup,
     ]
 
   }
 
-  enum serializedData: SwiftProtobuf.Enum {
+  enum singularInt32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSerializedData // = 0
+    case noneSingularInt32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSerializedData
+      self = .noneSingularInt32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSerializedData
+      case 0: self = .noneSingularInt32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSerializedData: return 0
+      case .noneSingularInt32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedData] = [
-      .noneSerializedData,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularInt32] = [
+      .noneSingularInt32,
     ]
 
   }
 
-  enum serializedSize: SwiftProtobuf.Enum {
+  enum singularInt64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSerializedSize // = 0
+    case noneSingularInt64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSerializedSize
+      self = .noneSingularInt64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSerializedSize
+      case 0: self = .noneSingularInt64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSerializedSize: return 0
+      case .noneSingularInt64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedSize] = [
-      .noneSerializedSize,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularInt64] = [
+      .noneSingularInt64,
     ]
 
   }
 
-  enum serverStreaming: SwiftProtobuf.Enum {
+  enum singularMessage: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneServerStreaming // = 0
+    case noneSingularMessage // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneServerStreaming
+      self = .noneSingularMessage
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneServerStreaming
+      case 0: self = .noneSingularMessage
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneServerStreaming: return 0
+      case .noneSingularMessage: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serverStreaming] = [
-      .noneServerStreaming,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularMessage] = [
+      .noneSingularMessage,
     ]
 
   }
 
-  enum service: SwiftProtobuf.Enum {
+  enum singularSFixed32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneService // = 0
+    case noneSingularSfixed32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneService
+      self = .noneSingularSfixed32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneService
+      case 0: self = .noneSingularSfixed32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneService: return 0
+      case .noneSingularSfixed32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.service] = [
-      .noneService,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularSFixed32] = [
+      .noneSingularSfixed32,
     ]
 
   }
 
-  enum ServiceDescriptorProto: SwiftProtobuf.Enum {
+  enum singularSFixed64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneServiceDescriptorProto // = 0
+    case noneSingularSfixed64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneServiceDescriptorProto
+      self = .noneSingularSfixed64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneServiceDescriptorProto
+      case 0: self = .noneSingularSfixed64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneServiceDescriptorProto: return 0
+      case .noneSingularSfixed64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ServiceDescriptorProto] = [
-      .noneServiceDescriptorProto,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularSFixed64] = [
+      .noneSingularSfixed64,
     ]
 
   }
 
-  enum ServiceOptions: SwiftProtobuf.Enum {
+  enum singularSInt32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneServiceOptions // = 0
+    case noneSingularSint32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneServiceOptions
+      self = .noneSingularSint32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneServiceOptions
+      case 0: self = .noneSingularSint32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneServiceOptions: return 0
+      case .noneSingularSint32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ServiceOptions] = [
-      .noneServiceOptions,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularSInt32] = [
+      .noneSingularSint32,
     ]
 
   }
 
-  enum set: SwiftProtobuf.Enum {
+  enum singularSInt64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSet // = 0
+    case noneSingularSint64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSet
+      self = .noneSingularSint64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSet
+      case 0: self = .noneSingularSint64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSet: return 0
+      case .noneSingularSint64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.set] = [
-      .noneSet,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularSInt64] = [
+      .noneSingularSint64,
     ]
 
   }
 
-  enum setExtensionValue: SwiftProtobuf.Enum {
+  enum singularString: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSetExtensionValue // = 0
+    case noneSingularString // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSetExtensionValue
+      self = .noneSingularString
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSetExtensionValue
+      case 0: self = .noneSingularString
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSetExtensionValue: return 0
+      case .noneSingularString: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.setExtensionValue] = [
-      .noneSetExtensionValue,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularString] = [
+      .noneSingularString,
     ]
 
   }
 
-  enum shift: SwiftProtobuf.Enum {
+  enum singularUInt32: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneShift // = 0
+    case noneSingularUint32 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneShift
+      self = .noneSingularUint32
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneShift
+      case 0: self = .noneSingularUint32
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneShift: return 0
+      case .noneSingularUint32: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.shift] = [
-      .noneShift,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularUInt32] = [
+      .noneSingularUint32,
     ]
 
   }
 
-  enum SimpleExtensionMap: SwiftProtobuf.Enum {
+  enum singularUInt64: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneSimpleExtensionMap // = 0
+    case noneSingularUint64 // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneSimpleExtensionMap
+      self = .noneSingularUint64
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneSimpleExtensionMap
+      case 0: self = .noneSingularUint64
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneSimpleExtensionMap: return 0
+      case .noneSingularUint64: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SimpleExtensionMap] = [
-      .noneSimpleExtensionMap,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularUInt64] = [
+      .noneSingularUint64,
     ]
 
   }
@@ -24841,62 +26551,92 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable {
 
   }
 
-  enum timeIntervalSinceReferenceDate: SwiftProtobuf.Enum {
+  enum timeIntervalSinceReferenceDate: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case noneTimeIntervalSinceReferenceDate // = 0
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .noneTimeIntervalSinceReferenceDate
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .noneTimeIntervalSinceReferenceDate
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .noneTimeIntervalSinceReferenceDate: return 0
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+    // The compiler won't synthesize support with the UNRECOGNIZED case.
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate] = [
+      .noneTimeIntervalSinceReferenceDate,
+    ]
+
+  }
+
+  enum Timestamp: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneTimeIntervalSinceReferenceDate // = 0
+    case noneTimestamp // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneTimeIntervalSinceReferenceDate
+      self = .noneTimestamp
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneTimeIntervalSinceReferenceDate
+      case 0: self = .noneTimestamp
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneTimeIntervalSinceReferenceDate: return 0
+      case .noneTimestamp: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate] = [
-      .noneTimeIntervalSinceReferenceDate,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Timestamp] = [
+      .noneTimestamp,
     ]
 
   }
 
-  enum Timestamp: SwiftProtobuf.Enum {
+  enum toConcrete: SwiftProtobuf.Enum {
     typealias RawValue = Int
-    case noneTimestamp // = 0
+    case noneToConcrete // = 0
     case UNRECOGNIZED(Int)
 
     init() {
-      self = .noneTimestamp
+      self = .noneToConcrete
     }
 
     init?(rawValue: Int) {
       switch rawValue {
-      case 0: self = .noneTimestamp
+      case 0: self = .noneToConcrete
       default: self = .UNRECOGNIZED(rawValue)
       }
     }
 
     var rawValue: Int {
       switch self {
-      case .noneTimestamp: return 0
+      case .noneToConcrete: return 0
       case .UNRECOGNIZED(let i): return i
       }
     }
 
     // The compiler won't synthesize support with the UNRECOGNIZED case.
-    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Timestamp] = [
-      .noneTimestamp,
+    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.toConcrete] = [
+      .noneToConcrete,
     ]
 
   }
@@ -28757,9 +30497,9 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: SwiftProtobuf
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -30429,6 +32169,12 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Error: SwiftPr
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.escaping: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_escaping"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_ExpressibleByArrayLiteral"),
@@ -30495,6 +32241,18 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionField
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionFields: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_extensionFields"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_extensionFieldsAsMessageSet"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_ExtensionFieldValueSet"),
@@ -30837,6 +32595,12 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.getExtensionVa
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.getValue: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_getValue"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.googleapis: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_googleapis"),
@@ -31899,6 +33663,12 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isNegative: Sw
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isUnset: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_isUnset"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_itemTagsEncodedSize"),
@@ -32223,6 +33993,12 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeIterator:
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.map: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_map"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapEntry: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_mapEntry"),
@@ -32559,6 +34335,12 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.of: SwiftProto
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneOf: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_oneOf"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofDecl: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_oneofDecl"),
@@ -32697,6 +34479,24 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packed: SwiftP
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedBool: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedBool"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedDouble: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedDouble"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedEnum: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedEnum"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_PackedEnumExtensionField"),
@@ -32709,6 +34509,72 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedExtensio
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedFixed32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedFixed32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedFixed64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedFixed64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedFloat: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedFloat"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedInt32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedInt32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedInt64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedInt64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedSFixed32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedSFixed32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedSFixed64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedSFixed64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedSInt32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedSInt32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedSInt64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedSInt64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedUInt32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedUInt32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packedUInt64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_packedUInt64"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.padding: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_padding"),
@@ -33165,6 +35031,30 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeated: Swif
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedBool: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedBool"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedBytes: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedBytes"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedDouble: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedDouble"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedEnum: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedEnum"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_RepeatedEnumExtensionField"),
@@ -33183,18 +35073,102 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFieldE
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFixed32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedFixed32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFixed64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedFixed64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFloat: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedFloat"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedGroup: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedGroup"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_RepeatedGroupExtensionField"),
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedInt32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedInt32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedInt64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedInt64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedMessage: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedMessage"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_RepeatedMessageExtensionField"),
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedSFixed32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedSFixed32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedSFixed64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedSFixed64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedSInt32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedSInt32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedSInt64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedSInt64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedString: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedString"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedUInt32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedUInt32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedUInt64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_repeatedUInt64"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeating: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_repeating"),
@@ -33417,6 +35391,114 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SimpleExtensio
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularBool: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularBool"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularBytes: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularBytes"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularDouble: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularDouble"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularEnum: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularEnum"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularFixed32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularFixed32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularFixed64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularFixed64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularFloat: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularFloat"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularGroup: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularGroup"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularInt32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularInt32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularInt64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularInt64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularMessage: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularMessage"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularSFixed32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularSFixed32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularSFixed64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularSFixed64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularSInt32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularSInt32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularSInt64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularSInt64"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularString: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularString"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularUInt32: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularUInt32"),
+  ]
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.singularUInt64: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_singularUInt64"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.size: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_size"),
@@ -33741,6 +35823,12 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Timestamp: Swi
   ]
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.toConcrete: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NONE_toConcrete"),
+  ]
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.total: SwiftProtobuf._ProtoNameProviding {
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     0: .same(proto: "NONE_total"),
diff --git a/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift b/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift
index 01f80216c..6b8c7f179 100644
--- a/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift
+++ b/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift
@@ -1414,6 +1414,11 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._error = newValue}
   }
 
+  var escaping: Int32 {
+    get {return _storage._escaping}
+    set {_uniqueStorage()._escaping = newValue}
+  }
+
   var expressibleByArrayLiteral: Int32 {
     get {return _storage._expressibleByArrayLiteral}
     set {_uniqueStorage()._expressibleByArrayLiteral = newValue}
@@ -1469,6 +1474,16 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._extensionFieldNumber = newValue}
   }
 
+  var extensionFields: Int32 {
+    get {return _storage._extensionFields}
+    set {_uniqueStorage()._extensionFields = newValue}
+  }
+
+  var extensionFieldsAsMessageSet: Int32 {
+    get {return _storage._extensionFieldsAsMessageSet}
+    set {_uniqueStorage()._extensionFieldsAsMessageSet = newValue}
+  }
+
   var extensionFieldValueSet: Int32 {
     get {return _storage._extensionFieldValueSet}
     set {_uniqueStorage()._extensionFieldValueSet = newValue}
@@ -1754,6 +1769,11 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._getExtensionValue = newValue}
   }
 
+  var getValue: Int32 {
+    get {return _storage._getValue}
+    set {_uniqueStorage()._getValue = newValue}
+  }
+
   var googleapis: Int32 {
     get {return _storage._googleapis}
     set {_uniqueStorage()._googleapis = newValue}
@@ -2639,6 +2659,11 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._isNegative = newValue}
   }
 
+  var isUnset: Int32 {
+    get {return _storage._isUnset}
+    set {_uniqueStorage()._isUnset = newValue}
+  }
+
   var itemTagsEncodedSize: Int32 {
     get {return _storage._itemTagsEncodedSize}
     set {_uniqueStorage()._itemTagsEncodedSize = newValue}
@@ -2909,6 +2934,11 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._makeIterator = newValue}
   }
 
+  var map: Int32 {
+    get {return _storage._map}
+    set {_uniqueStorage()._map = newValue}
+  }
+
   var mapEntry: Int32 {
     get {return _storage._mapEntry}
     set {_uniqueStorage()._mapEntry = newValue}
@@ -3189,6 +3219,11 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._of = newValue}
   }
 
+  var oneOf: Int32 {
+    get {return _storage._oneOf}
+    set {_uniqueStorage()._oneOf = newValue}
+  }
+
   var oneofDecl: Int32 {
     get {return _storage._oneofDecl}
     set {_uniqueStorage()._oneofDecl = newValue}
@@ -3304,6 +3339,21 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._packed = newValue}
   }
 
+  var packedBool: Int32 {
+    get {return _storage._packedBool}
+    set {_uniqueStorage()._packedBool = newValue}
+  }
+
+  var packedDouble: Int32 {
+    get {return _storage._packedDouble}
+    set {_uniqueStorage()._packedDouble = newValue}
+  }
+
+  var packedEnum: Int32 {
+    get {return _storage._packedEnum}
+    set {_uniqueStorage()._packedEnum = newValue}
+  }
+
   var packedEnumExtensionField: Int32 {
     get {return _storage._packedEnumExtensionField}
     set {_uniqueStorage()._packedEnumExtensionField = newValue}
@@ -3314,6 +3364,61 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._packedExtensionField = newValue}
   }
 
+  var packedFixed32: Int32 {
+    get {return _storage._packedFixed32}
+    set {_uniqueStorage()._packedFixed32 = newValue}
+  }
+
+  var packedFixed64: Int32 {
+    get {return _storage._packedFixed64}
+    set {_uniqueStorage()._packedFixed64 = newValue}
+  }
+
+  var packedFloat: Int32 {
+    get {return _storage._packedFloat}
+    set {_uniqueStorage()._packedFloat = newValue}
+  }
+
+  var packedInt32: Int32 {
+    get {return _storage._packedInt32}
+    set {_uniqueStorage()._packedInt32 = newValue}
+  }
+
+  var packedInt64: Int32 {
+    get {return _storage._packedInt64}
+    set {_uniqueStorage()._packedInt64 = newValue}
+  }
+
+  var packedSfixed32: Int32 {
+    get {return _storage._packedSfixed32}
+    set {_uniqueStorage()._packedSfixed32 = newValue}
+  }
+
+  var packedSfixed64: Int32 {
+    get {return _storage._packedSfixed64}
+    set {_uniqueStorage()._packedSfixed64 = newValue}
+  }
+
+  var packedSint32: Int32 {
+    get {return _storage._packedSint32}
+    set {_uniqueStorage()._packedSint32 = newValue}
+  }
+
+  var packedSint64: Int32 {
+    get {return _storage._packedSint64}
+    set {_uniqueStorage()._packedSint64 = newValue}
+  }
+
+  var packedUint32: Int32 {
+    get {return _storage._packedUint32}
+    set {_uniqueStorage()._packedUint32 = newValue}
+  }
+
+  var packedUint64: Int32 {
+    get {return _storage._packedUint64}
+    set {_uniqueStorage()._packedUint64 = newValue}
+  }
+
   var padding: Int32 {
     get {return _storage._padding}
     set {_uniqueStorage()._padding = newValue}
@@ -3694,6 +3799,26 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._repeated = newValue}
   }
 
+  var repeatedBool: Int32 {
+    get {return _storage._repeatedBool}
+    set {_uniqueStorage()._repeatedBool = newValue}
+  }
+
+  var repeatedBytes: Int32 {
+    get {return _storage._repeatedBytes}
+    set {_uniqueStorage()._repeatedBytes = newValue}
+  }
+
+  var repeatedDouble: Int32 {
+    get {return _storage._repeatedDouble}
+    set {_uniqueStorage()._repeatedDouble = newValue}
+  }
+
+  var repeatedEnum: Int32 {
+    get {return _storage._repeatedEnum}
+    set {_uniqueStorage()._repeatedEnum = newValue}
+  }
+
   var repeatedEnumExtensionField: Int32 {
     get {return _storage._repeatedEnumExtensionField}
     set {_uniqueStorage()._repeatedEnumExtensionField = newValue}
@@ -3709,16 +3834,86 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._repeatedFieldEncoding = newValue}
   }
 
+  var repeatedFixed32: Int32 {
+    get {return _storage._repeatedFixed32}
+    set {_uniqueStorage()._repeatedFixed32 = newValue}
+  }
+
+  var repeatedFixed64: Int32 {
+    get {return _storage._repeatedFixed64}
+    set {_uniqueStorage()._repeatedFixed64 = newValue}
+  }
+
+  var repeatedFloat: Int32 {
+    get {return _storage._repeatedFloat}
+    set {_uniqueStorage()._repeatedFloat = newValue}
+  }
+
+  var repeatedGroup: Int32 {
+    get {return _storage._repeatedGroup}
+    set {_uniqueStorage()._repeatedGroup = newValue}
+  }
+
   var repeatedGroupExtensionField: Int32 {
     get {return _storage._repeatedGroupExtensionField}
     set {_uniqueStorage()._repeatedGroupExtensionField = newValue}
   }
 
+  var repeatedInt32: Int32 {
+    get {return _storage._repeatedInt32}
+    set {_uniqueStorage()._repeatedInt32 = newValue}
+  }
+
+  var repeatedInt64: Int32 {
+    get {return _storage._repeatedInt64}
+    set {_uniqueStorage()._repeatedInt64 = newValue}
+  }
+
+  var repeatedMessage: Int32 {
+    get {return _storage._repeatedMessage}
+    set {_uniqueStorage()._repeatedMessage = newValue}
+  }
+
   var repeatedMessageExtensionField: Int32 {
     get {return _storage._repeatedMessageExtensionField}
     set {_uniqueStorage()._repeatedMessageExtensionField = newValue}
   }
 
+  var repeatedSfixed32: Int32 {
+    get {return _storage._repeatedSfixed32}
+    set {_uniqueStorage()._repeatedSfixed32 = newValue}
+  }
+
+  var repeatedSfixed64: Int32 {
+    get {return _storage._repeatedSfixed64}
+    set {_uniqueStorage()._repeatedSfixed64 = newValue}
+  }
+
+  var repeatedSint32: Int32 {
+    get {return _storage._repeatedSint32}
+    set {_uniqueStorage()._repeatedSint32 = newValue}
+  }
+
+  var repeatedSint64: Int32 {
+    get {return _storage._repeatedSint64}
+    set {_uniqueStorage()._repeatedSint64 = newValue}
+  }
+
+  var repeatedString: Int32 {
+    get {return _storage._repeatedString}
+    set {_uniqueStorage()._repeatedString = newValue}
+  }
+
+  var repeatedUint32: Int32 {
+    get {return _storage._repeatedUint32}
+    set {_uniqueStorage()._repeatedUint32 = newValue}
+  }
+
+  var repeatedUint64: Int32 {
+    get {return _storage._repeatedUint64}
+    set {_uniqueStorage()._repeatedUint64 = newValue}
+  }
+
   var repeating: Int32 {
     get {return _storage._repeating}
     set {_uniqueStorage()._repeating = newValue}
@@ -3904,6 +4099,96 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._simpleExtensionMap = newValue}
   }
 
+  var singularBool: Int32 {
+    get {return _storage._singularBool}
+    set {_uniqueStorage()._singularBool = newValue}
+  }
+
+  var singularBytes: Int32 {
+    get {return _storage._singularBytes}
+    set {_uniqueStorage()._singularBytes = newValue}
+  }
+
+  var singularDouble: Int32 {
+    get {return _storage._singularDouble}
+    set {_uniqueStorage()._singularDouble = newValue}
+  }
+
+  var singularEnum: Int32 {
+    get {return _storage._singularEnum}
+    set {_uniqueStorage()._singularEnum = newValue}
+  }
+
+  var singularFixed32: Int32 {
+    get {return _storage._singularFixed32}
+    set {_uniqueStorage()._singularFixed32 = newValue}
+  }
+
+  var singularFixed64: Int32 {
+    get {return _storage._singularFixed64}
+    set {_uniqueStorage()._singularFixed64 = newValue}
+  }
+
+  var singularFloat: Int32 {
+    get {return _storage._singularFloat}
+    set {_uniqueStorage()._singularFloat = newValue}
+  }
+
+  var singularGroup: Int32 {
+    get {return _storage._singularGroup}
+    set {_uniqueStorage()._singularGroup = newValue}
+  }
+
+  var singularInt32: Int32 {
+    get {return _storage._singularInt32}
+    set {_uniqueStorage()._singularInt32 = newValue}
+  }
+
+  var singularInt64: Int32 {
+    get {return _storage._singularInt64}
+    set {_uniqueStorage()._singularInt64 = newValue}
+  }
+
+  var singularMessage: Int32 {
+    get {return _storage._singularMessage}
+    set {_uniqueStorage()._singularMessage = newValue}
+  }
+
+  var singularSfixed32: Int32 {
+    get {return _storage._singularSfixed32}
+    set {_uniqueStorage()._singularSfixed32 = newValue}
+  }
+
+  var singularSfixed64: Int32 {
+    get {return _storage._singularSfixed64}
+    set {_uniqueStorage()._singularSfixed64 = newValue}
+  }
+
+  var singularSint32: Int32 {
+    get {return _storage._singularSint32}
+    set {_uniqueStorage()._singularSint32 = newValue}
+  }
+
+  var singularSint64: Int32 {
+    get {return _storage._singularSint64}
+    set {_uniqueStorage()._singularSint64 = newValue}
+  }
+
+  var singularString: Int32 {
+    get {return _storage._singularString}
+    set {_uniqueStorage()._singularString = newValue}
+  }
+
+  var singularUint32: Int32 {
+    get {return _storage._singularUint32}
+    set {_uniqueStorage()._singularUint32 = newValue}
+  }
+
+  var singularUint64: Int32 {
+    get {return _storage._singularUint64}
+    set {_uniqueStorage()._singularUint64 = newValue}
+  }
+
   var size: Int32 {
     get {return _storage._size}
     set {_uniqueStorage()._size = newValue}
@@ -4174,6 +4459,11 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Send
     set {_uniqueStorage()._timestamp = newValue}
   }
 
+  var toConcrete: Int32 {
+    get {return _storage._toConcrete}
+    set {_uniqueStorage()._toConcrete = newValue}
+  }
+
   var total: Int32 {
     get {return _storage._total}
     set {_uniqueStorage()._total = newValue}
@@ -5105,686 +5395,744 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     275: .same(proto: "EnumValueOptions"),
     276: .same(proto: "Equatable"),
     277: .same(proto: "Error"),
-    278: .same(proto: "ExpressibleByArrayLiteral"),
-    279: .same(proto: "ExpressibleByDictionaryLiteral"),
-    280: .same(proto: "ext"),
-    281: .same(proto: "extDecoder"),
-    282: .same(proto: "extendedGraphemeClusterLiteral"),
-    283: .same(proto: "ExtendedGraphemeClusterLiteralType"),
-    284: .same(proto: "extendee"),
-    285: .same(proto: "ExtensibleMessage"),
-    286: .same(proto: "extension"),
-    287: .same(proto: "ExtensionField"),
-    288: .same(proto: "extensionFieldNumber"),
-    289: .same(proto: "ExtensionFieldValueSet"),
-    290: .same(proto: "ExtensionMap"),
-    291: .same(proto: "extensionRange"),
-    292: .same(proto: "ExtensionRangeOptions"),
-    293: .same(proto: "extensions"),
-    294: .same(proto: "extras"),
-    295: .same(proto: "F"),
-    296: .same(proto: "false"),
-    297: .same(proto: "features"),
-    298: .same(proto: "FeatureSet"),
-    299: .same(proto: "FeatureSetDefaults"),
-    300: .same(proto: "FeatureSetEditionDefault"),
-    301: .same(proto: "field"),
-    302: .same(proto: "fieldData"),
-    303: .same(proto: "FieldDescriptorProto"),
-    304: .same(proto: "FieldMask"),
-    305: .same(proto: "fieldName"),
-    306: .same(proto: "fieldNameCount"),
-    307: .same(proto: "fieldNum"),
-    308: .same(proto: "fieldNumber"),
-    309: .same(proto: "fieldNumberForProto"),
-    310: .same(proto: "FieldOptions"),
-    311: .same(proto: "fieldPresence"),
-    312: .same(proto: "fields"),
-    313: .same(proto: "fieldSize"),
-    314: .same(proto: "FieldTag"),
-    315: .same(proto: "fieldType"),
-    316: .same(proto: "file"),
-    317: .same(proto: "FileDescriptorProto"),
-    318: .same(proto: "FileDescriptorSet"),
-    319: .same(proto: "fileName"),
-    320: .same(proto: "FileOptions"),
-    321: .same(proto: "filter"),
-    322: .same(proto: "final"),
-    323: .same(proto: "first"),
-    324: .same(proto: "firstItem"),
-    325: .same(proto: "Float"),
-    326: .same(proto: "floatLiteral"),
-    327: .same(proto: "FloatLiteralType"),
-    328: .same(proto: "FloatValue"),
-    329: .same(proto: "forMessageName"),
-    330: .same(proto: "formUnion"),
-    331: .same(proto: "forReadingFrom"),
-    332: .same(proto: "forTypeURL"),
-    333: .same(proto: "ForwardParser"),
-    334: .same(proto: "forWritingInto"),
-    335: .same(proto: "from"),
-    336: .same(proto: "fromAscii2"),
-    337: .same(proto: "fromAscii4"),
-    338: .same(proto: "fromByteOffset"),
-    339: .same(proto: "fromHexDigit"),
-    340: .same(proto: "fullName"),
-    341: .same(proto: "func"),
-    342: .same(proto: "G"),
-    343: .same(proto: "GeneratedCodeInfo"),
-    344: .same(proto: "get"),
-    345: .same(proto: "getExtensionValue"),
-    346: .same(proto: "googleapis"),
-    347: .standard(proto: "Google_Protobuf_Any"),
-    348: .standard(proto: "Google_Protobuf_Api"),
-    349: .standard(proto: "Google_Protobuf_BoolValue"),
-    350: .standard(proto: "Google_Protobuf_BytesValue"),
-    351: .standard(proto: "Google_Protobuf_DescriptorProto"),
-    352: .standard(proto: "Google_Protobuf_DoubleValue"),
-    353: .standard(proto: "Google_Protobuf_Duration"),
-    354: .standard(proto: "Google_Protobuf_Edition"),
-    355: .standard(proto: "Google_Protobuf_Empty"),
-    356: .standard(proto: "Google_Protobuf_Enum"),
-    357: .standard(proto: "Google_Protobuf_EnumDescriptorProto"),
-    358: .standard(proto: "Google_Protobuf_EnumOptions"),
-    359: .standard(proto: "Google_Protobuf_EnumValue"),
-    360: .standard(proto: "Google_Protobuf_EnumValueDescriptorProto"),
-    361: .standard(proto: "Google_Protobuf_EnumValueOptions"),
-    362: .standard(proto: "Google_Protobuf_ExtensionRangeOptions"),
-    363: .standard(proto: "Google_Protobuf_FeatureSet"),
-    364: .standard(proto: "Google_Protobuf_FeatureSetDefaults"),
-    365: .standard(proto: "Google_Protobuf_Field"),
-    366: .standard(proto: "Google_Protobuf_FieldDescriptorProto"),
-    367: .standard(proto: "Google_Protobuf_FieldMask"),
-    368: .standard(proto: "Google_Protobuf_FieldOptions"),
-    369: .standard(proto: "Google_Protobuf_FileDescriptorProto"),
-    370: .standard(proto: "Google_Protobuf_FileDescriptorSet"),
-    371: .standard(proto: "Google_Protobuf_FileOptions"),
-    372: .standard(proto: "Google_Protobuf_FloatValue"),
-    373: .standard(proto: "Google_Protobuf_GeneratedCodeInfo"),
-    374: .standard(proto: "Google_Protobuf_Int32Value"),
-    375: .standard(proto: "Google_Protobuf_Int64Value"),
-    376: .standard(proto: "Google_Protobuf_ListValue"),
-    377: .standard(proto: "Google_Protobuf_MessageOptions"),
-    378: .standard(proto: "Google_Protobuf_Method"),
-    379: .standard(proto: "Google_Protobuf_MethodDescriptorProto"),
-    380: .standard(proto: "Google_Protobuf_MethodOptions"),
-    381: .standard(proto: "Google_Protobuf_Mixin"),
-    382: .standard(proto: "Google_Protobuf_NullValue"),
-    383: .standard(proto: "Google_Protobuf_OneofDescriptorProto"),
-    384: .standard(proto: "Google_Protobuf_OneofOptions"),
-    385: .standard(proto: "Google_Protobuf_Option"),
-    386: .standard(proto: "Google_Protobuf_ServiceDescriptorProto"),
-    387: .standard(proto: "Google_Protobuf_ServiceOptions"),
-    388: .standard(proto: "Google_Protobuf_SourceCodeInfo"),
-    389: .standard(proto: "Google_Protobuf_SourceContext"),
-    390: .standard(proto: "Google_Protobuf_StringValue"),
-    391: .standard(proto: "Google_Protobuf_Struct"),
-    392: .standard(proto: "Google_Protobuf_Syntax"),
-    393: .standard(proto: "Google_Protobuf_Timestamp"),
-    394: .standard(proto: "Google_Protobuf_Type"),
-    395: .standard(proto: "Google_Protobuf_UInt32Value"),
-    396: .standard(proto: "Google_Protobuf_UInt64Value"),
-    397: .standard(proto: "Google_Protobuf_UninterpretedOption"),
-    398: .standard(proto: "Google_Protobuf_Value"),
-    399: .same(proto: "goPackage"),
-    400: .same(proto: "group"),
-    401: .same(proto: "groupFieldNumberStack"),
-    402: .same(proto: "groupSize"),
-    403: .same(proto: "hadOneofValue"),
-    404: .same(proto: "handleConflictingOneOf"),
-    405: .same(proto: "hasAggregateValue"),
-    406: .same(proto: "hasAllowAlias"),
-    407: .same(proto: "hasBegin"),
-    408: .same(proto: "hasCcEnableArenas"),
-    409: .same(proto: "hasCcGenericServices"),
-    410: .same(proto: "hasClientStreaming"),
-    411: .same(proto: "hasCsharpNamespace"),
-    412: .same(proto: "hasCtype"),
-    413: .same(proto: "hasDebugRedact"),
-    414: .same(proto: "hasDefaultValue"),
-    415: .same(proto: "hasDeprecated"),
-    416: .same(proto: "hasDeprecatedLegacyJsonFieldConflicts"),
-    417: .same(proto: "hasDoubleValue"),
-    418: .same(proto: "hasEdition"),
-    419: .same(proto: "hasEnd"),
-    420: .same(proto: "hasEnumType"),
-    421: .same(proto: "hasExtendee"),
-    422: .same(proto: "hasExtensionValue"),
-    423: .same(proto: "hasFeatures"),
-    424: .same(proto: "hasFieldPresence"),
-    425: .same(proto: "hasFullName"),
-    426: .same(proto: "hasGoPackage"),
-    427: .same(proto: "hash"),
-    428: .same(proto: "Hashable"),
-    429: .same(proto: "hasher"),
-    430: .same(proto: "HashVisitor"),
-    431: .same(proto: "hasIdempotencyLevel"),
-    432: .same(proto: "hasIdentifierValue"),
-    433: .same(proto: "hasInputType"),
-    434: .same(proto: "hasIsExtension"),
-    435: .same(proto: "hasJavaGenerateEqualsAndHash"),
-    436: .same(proto: "hasJavaGenericServices"),
-    437: .same(proto: "hasJavaMultipleFiles"),
-    438: .same(proto: "hasJavaOuterClassname"),
-    439: .same(proto: "hasJavaPackage"),
-    440: .same(proto: "hasJavaStringCheckUtf8"),
-    441: .same(proto: "hasJsonFormat"),
-    442: .same(proto: "hasJsonName"),
-    443: .same(proto: "hasJstype"),
-    444: .same(proto: "hasLabel"),
-    445: .same(proto: "hasLazy"),
-    446: .same(proto: "hasLeadingComments"),
-    447: .same(proto: "hasMapEntry"),
-    448: .same(proto: "hasMaximumEdition"),
-    449: .same(proto: "hasMessageEncoding"),
-    450: .same(proto: "hasMessageSetWireFormat"),
-    451: .same(proto: "hasMinimumEdition"),
-    452: .same(proto: "hasName"),
-    453: .same(proto: "hasNamePart"),
-    454: .same(proto: "hasNegativeIntValue"),
-    455: .same(proto: "hasNoStandardDescriptorAccessor"),
-    456: .same(proto: "hasNumber"),
-    457: .same(proto: "hasObjcClassPrefix"),
-    458: .same(proto: "hasOneofIndex"),
-    459: .same(proto: "hasOptimizeFor"),
-    460: .same(proto: "hasOptions"),
-    461: .same(proto: "hasOutputType"),
-    462: .same(proto: "hasPackage"),
-    463: .same(proto: "hasPacked"),
-    464: .same(proto: "hasPhpClassPrefix"),
-    465: .same(proto: "hasPhpGenericServices"),
-    466: .same(proto: "hasPhpMetadataNamespace"),
-    467: .same(proto: "hasPhpNamespace"),
-    468: .same(proto: "hasPositiveIntValue"),
-    469: .same(proto: "hasProto3Optional"),
-    470: .same(proto: "hasPyGenericServices"),
-    471: .same(proto: "hasRepeated"),
-    472: .same(proto: "hasRepeatedFieldEncoding"),
-    473: .same(proto: "hasReserved"),
-    474: .same(proto: "hasRetention"),
-    475: .same(proto: "hasRubyPackage"),
-    476: .same(proto: "hasSemantic"),
-    477: .same(proto: "hasServerStreaming"),
-    478: .same(proto: "hasSourceCodeInfo"),
-    479: .same(proto: "hasSourceContext"),
-    480: .same(proto: "hasSourceFile"),
-    481: .same(proto: "hasStart"),
-    482: .same(proto: "hasStringValue"),
-    483: .same(proto: "hasSwiftPrefix"),
-    484: .same(proto: "hasSyntax"),
-    485: .same(proto: "hasTrailingComments"),
-    486: .same(proto: "hasType"),
-    487: .same(proto: "hasTypeName"),
-    488: .same(proto: "hasUnverifiedLazy"),
-    489: .same(proto: "hasUtf8Validation"),
-    490: .same(proto: "hasValue"),
-    491: .same(proto: "hasVerification"),
-    492: .same(proto: "hasWeak"),
-    493: .same(proto: "hour"),
-    494: .same(proto: "i"),
-    495: .same(proto: "idempotencyLevel"),
-    496: .same(proto: "identifierValue"),
-    497: .same(proto: "if"),
-    498: .same(proto: "ignoreUnknownFields"),
-    499: .same(proto: "index"),
-    500: .same(proto: "init"),
-    501: .same(proto: "inout"),
-    502: .same(proto: "inputType"),
-    503: .same(proto: "insert"),
-    504: .same(proto: "Int"),
-    505: .same(proto: "Int32"),
-    506: .same(proto: "Int32Value"),
-    507: .same(proto: "Int64"),
-    508: .same(proto: "Int64Value"),
-    509: .same(proto: "Int8"),
-    510: .same(proto: "integerLiteral"),
-    511: .same(proto: "IntegerLiteralType"),
-    512: .same(proto: "intern"),
-    513: .same(proto: "Internal"),
-    514: .same(proto: "InternalState"),
-    515: .same(proto: "into"),
-    516: .same(proto: "ints"),
-    517: .same(proto: "isA"),
-    518: .same(proto: "isEqual"),
-    519: .same(proto: "isEqualTo"),
-    520: .same(proto: "isExtension"),
-    521: .same(proto: "isInitialized"),
-    522: .same(proto: "isNegative"),
-    523: .same(proto: "itemTagsEncodedSize"),
-    524: .same(proto: "iterator"),
-    525: .same(proto: "javaGenerateEqualsAndHash"),
-    526: .same(proto: "javaGenericServices"),
-    527: .same(proto: "javaMultipleFiles"),
-    528: .same(proto: "javaOuterClassname"),
-    529: .same(proto: "javaPackage"),
-    530: .same(proto: "javaStringCheckUtf8"),
-    531: .same(proto: "JSONDecoder"),
-    532: .same(proto: "JSONDecodingError"),
-    533: .same(proto: "JSONDecodingOptions"),
-    534: .same(proto: "jsonEncoder"),
-    535: .same(proto: "JSONEncodingError"),
-    536: .same(proto: "JSONEncodingOptions"),
-    537: .same(proto: "JSONEncodingVisitor"),
-    538: .same(proto: "jsonFormat"),
-    539: .same(proto: "JSONMapEncodingVisitor"),
-    540: .same(proto: "jsonName"),
-    541: .same(proto: "jsonPath"),
-    542: .same(proto: "jsonPaths"),
-    543: .same(proto: "JSONScanner"),
-    544: .same(proto: "jsonString"),
-    545: .same(proto: "jsonText"),
-    546: .same(proto: "jsonUTF8Bytes"),
-    547: .same(proto: "jsonUTF8Data"),
-    548: .same(proto: "jstype"),
-    549: .same(proto: "k"),
-    550: .same(proto: "kChunkSize"),
-    551: .same(proto: "Key"),
-    552: .same(proto: "keyField"),
-    553: .same(proto: "keyFieldOpt"),
-    554: .same(proto: "KeyType"),
-    555: .same(proto: "kind"),
-    556: .same(proto: "l"),
-    557: .same(proto: "label"),
-    558: .same(proto: "lazy"),
-    559: .same(proto: "leadingComments"),
-    560: .same(proto: "leadingDetachedComments"),
-    561: .same(proto: "length"),
-    562: .same(proto: "lessThan"),
-    563: .same(proto: "let"),
-    564: .same(proto: "lhs"),
-    565: .same(proto: "list"),
-    566: .same(proto: "listOfMessages"),
-    567: .same(proto: "listValue"),
-    568: .same(proto: "littleEndian"),
-    569: .same(proto: "littleEndianBytes"),
-    570: .same(proto: "load"),
-    571: .same(proto: "localHasher"),
-    572: .same(proto: "location"),
-    573: .same(proto: "M"),
-    574: .same(proto: "major"),
-    575: .same(proto: "makeAsyncIterator"),
-    576: .same(proto: "makeIterator"),
-    577: .same(proto: "mapEntry"),
-    578: .same(proto: "MapKeyType"),
-    579: .same(proto: "mapToMessages"),
-    580: .same(proto: "MapValueType"),
-    581: .same(proto: "mapVisitor"),
-    582: .same(proto: "maximumEdition"),
-    583: .same(proto: "mdayStart"),
-    584: .same(proto: "merge"),
-    585: .same(proto: "message"),
-    586: .same(proto: "messageDepthLimit"),
-    587: .same(proto: "messageEncoding"),
-    588: .same(proto: "MessageExtension"),
-    589: .same(proto: "MessageImplementationBase"),
-    590: .same(proto: "MessageOptions"),
-    591: .same(proto: "MessageSet"),
-    592: .same(proto: "messageSetWireFormat"),
-    593: .same(proto: "messageSize"),
-    594: .same(proto: "messageType"),
-    595: .same(proto: "Method"),
-    596: .same(proto: "MethodDescriptorProto"),
-    597: .same(proto: "MethodOptions"),
-    598: .same(proto: "methods"),
-    599: .same(proto: "min"),
-    600: .same(proto: "minimumEdition"),
-    601: .same(proto: "minor"),
-    602: .same(proto: "Mixin"),
-    603: .same(proto: "mixins"),
-    604: .same(proto: "modifier"),
-    605: .same(proto: "modify"),
-    606: .same(proto: "month"),
-    607: .same(proto: "msgExtension"),
-    608: .same(proto: "mutating"),
-    609: .same(proto: "n"),
-    610: .same(proto: "name"),
-    611: .same(proto: "NameDescription"),
-    612: .same(proto: "NameMap"),
-    613: .same(proto: "NamePart"),
-    614: .same(proto: "names"),
-    615: .same(proto: "nanos"),
-    616: .same(proto: "negativeIntValue"),
-    617: .same(proto: "nestedType"),
-    618: .same(proto: "newL"),
-    619: .same(proto: "newList"),
-    620: .same(proto: "newValue"),
-    621: .same(proto: "next"),
-    622: .same(proto: "nextByte"),
-    623: .same(proto: "nextFieldNumber"),
-    624: .same(proto: "nextVarInt"),
-    625: .same(proto: "nil"),
-    626: .same(proto: "nilLiteral"),
-    627: .same(proto: "noStandardDescriptorAccessor"),
-    628: .same(proto: "nullValue"),
-    629: .same(proto: "number"),
-    630: .same(proto: "numberValue"),
-    631: .same(proto: "objcClassPrefix"),
-    632: .same(proto: "of"),
-    633: .same(proto: "oneofDecl"),
-    634: .same(proto: "OneofDescriptorProto"),
-    635: .same(proto: "oneofIndex"),
-    636: .same(proto: "OneofOptions"),
-    637: .same(proto: "oneofs"),
-    638: .standard(proto: "OneOf_Kind"),
-    639: .same(proto: "optimizeFor"),
-    640: .same(proto: "OptimizeMode"),
-    641: .same(proto: "Option"),
-    642: .same(proto: "OptionalEnumExtensionField"),
-    643: .same(proto: "OptionalExtensionField"),
-    644: .same(proto: "OptionalGroupExtensionField"),
-    645: .same(proto: "OptionalMessageExtensionField"),
-    646: .same(proto: "OptionRetention"),
-    647: .same(proto: "options"),
-    648: .same(proto: "OptionTargetType"),
-    649: .same(proto: "other"),
-    650: .same(proto: "others"),
-    651: .same(proto: "out"),
-    652: .same(proto: "outputType"),
-    653: .same(proto: "p"),
-    654: .same(proto: "package"),
-    655: .same(proto: "packed"),
-    656: .same(proto: "PackedEnumExtensionField"),
-    657: .same(proto: "PackedExtensionField"),
-    658: .same(proto: "padding"),
-    659: .same(proto: "parent"),
-    660: .same(proto: "parse"),
-    661: .same(proto: "path"),
-    662: .same(proto: "paths"),
-    663: .same(proto: "payload"),
-    664: .same(proto: "payloadSize"),
-    665: .same(proto: "phpClassPrefix"),
-    666: .same(proto: "phpGenericServices"),
-    667: .same(proto: "phpMetadataNamespace"),
-    668: .same(proto: "phpNamespace"),
-    669: .same(proto: "pos"),
-    670: .same(proto: "positiveIntValue"),
-    671: .same(proto: "prefix"),
-    672: .same(proto: "preserveProtoFieldNames"),
-    673: .same(proto: "preTraverse"),
-    674: .same(proto: "printUnknownFields"),
-    675: .same(proto: "proto2"),
-    676: .same(proto: "proto3DefaultValue"),
-    677: .same(proto: "proto3Optional"),
-    678: .same(proto: "ProtobufAPIVersionCheck"),
-    679: .standard(proto: "ProtobufAPIVersion_3"),
-    680: .same(proto: "ProtobufBool"),
-    681: .same(proto: "ProtobufBytes"),
-    682: .same(proto: "ProtobufDouble"),
-    683: .same(proto: "ProtobufEnumMap"),
-    684: .same(proto: "protobufExtension"),
-    685: .same(proto: "ProtobufFixed32"),
-    686: .same(proto: "ProtobufFixed64"),
-    687: .same(proto: "ProtobufFloat"),
-    688: .same(proto: "ProtobufInt32"),
-    689: .same(proto: "ProtobufInt64"),
-    690: .same(proto: "ProtobufMap"),
-    691: .same(proto: "ProtobufMessageMap"),
-    692: .same(proto: "ProtobufSFixed32"),
-    693: .same(proto: "ProtobufSFixed64"),
-    694: .same(proto: "ProtobufSInt32"),
-    695: .same(proto: "ProtobufSInt64"),
-    696: .same(proto: "ProtobufString"),
-    697: .same(proto: "ProtobufUInt32"),
-    698: .same(proto: "ProtobufUInt64"),
-    699: .standard(proto: "protobuf_extensionFieldValues"),
-    700: .standard(proto: "protobuf_fieldNumber"),
-    701: .standard(proto: "protobuf_generated_isEqualTo"),
-    702: .standard(proto: "protobuf_nameMap"),
-    703: .standard(proto: "protobuf_newField"),
-    704: .standard(proto: "protobuf_package"),
-    705: .same(proto: "protocol"),
-    706: .same(proto: "protoFieldName"),
-    707: .same(proto: "protoMessageName"),
-    708: .same(proto: "ProtoNameProviding"),
-    709: .same(proto: "protoPaths"),
-    710: .same(proto: "public"),
-    711: .same(proto: "publicDependency"),
-    712: .same(proto: "putBoolValue"),
-    713: .same(proto: "putBytesValue"),
-    714: .same(proto: "putDoubleValue"),
-    715: .same(proto: "putEnumValue"),
-    716: .same(proto: "putFixedUInt32"),
-    717: .same(proto: "putFixedUInt64"),
-    718: .same(proto: "putFloatValue"),
-    719: .same(proto: "putInt64"),
-    720: .same(proto: "putStringValue"),
-    721: .same(proto: "putUInt64"),
-    722: .same(proto: "putUInt64Hex"),
-    723: .same(proto: "putVarInt"),
-    724: .same(proto: "putZigZagVarInt"),
-    725: .same(proto: "pyGenericServices"),
-    726: .same(proto: "R"),
-    727: .same(proto: "rawChars"),
-    728: .same(proto: "RawRepresentable"),
-    729: .same(proto: "RawValue"),
-    730: .same(proto: "read4HexDigits"),
-    731: .same(proto: "readBytes"),
-    732: .same(proto: "register"),
-    733: .same(proto: "repeated"),
-    734: .same(proto: "RepeatedEnumExtensionField"),
-    735: .same(proto: "RepeatedExtensionField"),
-    736: .same(proto: "repeatedFieldEncoding"),
-    737: .same(proto: "RepeatedGroupExtensionField"),
-    738: .same(proto: "RepeatedMessageExtensionField"),
-    739: .same(proto: "repeating"),
-    740: .same(proto: "requestStreaming"),
-    741: .same(proto: "requestTypeURL"),
-    742: .same(proto: "requiredSize"),
-    743: .same(proto: "responseStreaming"),
-    744: .same(proto: "responseTypeURL"),
-    745: .same(proto: "result"),
-    746: .same(proto: "retention"),
-    747: .same(proto: "rethrows"),
-    748: .same(proto: "return"),
-    749: .same(proto: "ReturnType"),
-    750: .same(proto: "revision"),
-    751: .same(proto: "rhs"),
-    752: .same(proto: "root"),
-    753: .same(proto: "rubyPackage"),
-    754: .same(proto: "s"),
-    755: .same(proto: "sawBackslash"),
-    756: .same(proto: "sawSection4Characters"),
-    757: .same(proto: "sawSection5Characters"),
-    758: .same(proto: "scanner"),
-    759: .same(proto: "seconds"),
-    760: .same(proto: "self"),
-    761: .same(proto: "semantic"),
-    762: .same(proto: "Sendable"),
-    763: .same(proto: "separator"),
-    764: .same(proto: "serialize"),
-    765: .same(proto: "serializedBytes"),
-    766: .same(proto: "serializedData"),
-    767: .same(proto: "serializedSize"),
-    768: .same(proto: "serverStreaming"),
-    769: .same(proto: "service"),
-    770: .same(proto: "ServiceDescriptorProto"),
-    771: .same(proto: "ServiceOptions"),
-    772: .same(proto: "set"),
-    773: .same(proto: "setExtensionValue"),
-    774: .same(proto: "shift"),
-    775: .same(proto: "SimpleExtensionMap"),
-    776: .same(proto: "size"),
-    777: .same(proto: "sizer"),
-    778: .same(proto: "source"),
-    779: .same(proto: "sourceCodeInfo"),
-    780: .same(proto: "sourceContext"),
-    781: .same(proto: "sourceEncoding"),
-    782: .same(proto: "sourceFile"),
-    783: .same(proto: "span"),
-    784: .same(proto: "split"),
-    785: .same(proto: "start"),
-    786: .same(proto: "startArray"),
-    787: .same(proto: "startArrayObject"),
-    788: .same(proto: "startField"),
-    789: .same(proto: "startIndex"),
-    790: .same(proto: "startMessageField"),
-    791: .same(proto: "startObject"),
-    792: .same(proto: "startRegularField"),
-    793: .same(proto: "state"),
-    794: .same(proto: "static"),
-    795: .same(proto: "StaticString"),
-    796: .same(proto: "storage"),
-    797: .same(proto: "String"),
-    798: .same(proto: "stringLiteral"),
-    799: .same(proto: "StringLiteralType"),
-    800: .same(proto: "stringResult"),
-    801: .same(proto: "stringValue"),
-    802: .same(proto: "struct"),
-    803: .same(proto: "structValue"),
-    804: .same(proto: "subDecoder"),
-    805: .same(proto: "subscript"),
-    806: .same(proto: "subVisitor"),
-    807: .same(proto: "Swift"),
-    808: .same(proto: "swiftPrefix"),
-    809: .same(proto: "SwiftProtobufContiguousBytes"),
-    810: .same(proto: "syntax"),
-    811: .same(proto: "T"),
-    812: .same(proto: "tag"),
-    813: .same(proto: "targets"),
-    814: .same(proto: "terminator"),
-    815: .same(proto: "testDecoder"),
-    816: .same(proto: "text"),
-    817: .same(proto: "textDecoder"),
-    818: .same(proto: "TextFormatDecoder"),
-    819: .same(proto: "TextFormatDecodingError"),
-    820: .same(proto: "TextFormatDecodingOptions"),
-    821: .same(proto: "TextFormatEncodingOptions"),
-    822: .same(proto: "TextFormatEncodingVisitor"),
-    823: .same(proto: "textFormatString"),
-    824: .same(proto: "throwOrIgnore"),
-    825: .same(proto: "throws"),
-    826: .same(proto: "timeInterval"),
-    827: .same(proto: "timeIntervalSince1970"),
-    828: .same(proto: "timeIntervalSinceReferenceDate"),
-    829: .same(proto: "Timestamp"),
-    830: .same(proto: "total"),
-    831: .same(proto: "totalArrayDepth"),
-    832: .same(proto: "totalSize"),
-    833: .same(proto: "trailingComments"),
-    834: .same(proto: "traverse"),
-    835: .same(proto: "true"),
-    836: .same(proto: "try"),
-    837: .same(proto: "type"),
-    838: .same(proto: "typealias"),
-    839: .same(proto: "TypeEnum"),
-    840: .same(proto: "typeName"),
-    841: .same(proto: "typePrefix"),
-    842: .same(proto: "typeStart"),
-    843: .same(proto: "typeUnknown"),
-    844: .same(proto: "typeURL"),
-    845: .same(proto: "UInt32"),
-    846: .same(proto: "UInt32Value"),
-    847: .same(proto: "UInt64"),
-    848: .same(proto: "UInt64Value"),
-    849: .same(proto: "UInt8"),
-    850: .same(proto: "unchecked"),
-    851: .same(proto: "unicodeScalarLiteral"),
-    852: .same(proto: "UnicodeScalarLiteralType"),
-    853: .same(proto: "unicodeScalars"),
-    854: .same(proto: "UnicodeScalarView"),
-    855: .same(proto: "uninterpretedOption"),
-    856: .same(proto: "union"),
-    857: .same(proto: "uniqueStorage"),
-    858: .same(proto: "unknown"),
-    859: .same(proto: "unknownFields"),
-    860: .same(proto: "UnknownStorage"),
-    861: .same(proto: "unpackTo"),
-    862: .same(proto: "UnsafeBufferPointer"),
-    863: .same(proto: "UnsafeMutablePointer"),
-    864: .same(proto: "UnsafeMutableRawBufferPointer"),
-    865: .same(proto: "UnsafeRawBufferPointer"),
-    866: .same(proto: "UnsafeRawPointer"),
-    867: .same(proto: "unverifiedLazy"),
-    868: .same(proto: "updatedOptions"),
-    869: .same(proto: "url"),
-    870: .same(proto: "useDeterministicOrdering"),
-    871: .same(proto: "utf8"),
-    872: .same(proto: "utf8Ptr"),
-    873: .same(proto: "utf8ToDouble"),
-    874: .same(proto: "utf8Validation"),
-    875: .same(proto: "UTF8View"),
-    876: .same(proto: "v"),
-    877: .same(proto: "value"),
-    878: .same(proto: "valueField"),
-    879: .same(proto: "values"),
-    880: .same(proto: "ValueType"),
-    881: .same(proto: "var"),
-    882: .same(proto: "verification"),
-    883: .same(proto: "VerificationState"),
-    884: .same(proto: "Version"),
-    885: .same(proto: "versionString"),
-    886: .same(proto: "visitExtensionFields"),
-    887: .same(proto: "visitExtensionFieldsAsMessageSet"),
-    888: .same(proto: "visitMapField"),
-    889: .same(proto: "visitor"),
-    890: .same(proto: "visitPacked"),
-    891: .same(proto: "visitPackedBoolField"),
-    892: .same(proto: "visitPackedDoubleField"),
-    893: .same(proto: "visitPackedEnumField"),
-    894: .same(proto: "visitPackedFixed32Field"),
-    895: .same(proto: "visitPackedFixed64Field"),
-    896: .same(proto: "visitPackedFloatField"),
-    897: .same(proto: "visitPackedInt32Field"),
-    898: .same(proto: "visitPackedInt64Field"),
-    899: .same(proto: "visitPackedSFixed32Field"),
-    900: .same(proto: "visitPackedSFixed64Field"),
-    901: .same(proto: "visitPackedSInt32Field"),
-    902: .same(proto: "visitPackedSInt64Field"),
-    903: .same(proto: "visitPackedUInt32Field"),
-    904: .same(proto: "visitPackedUInt64Field"),
-    905: .same(proto: "visitRepeated"),
-    906: .same(proto: "visitRepeatedBoolField"),
-    907: .same(proto: "visitRepeatedBytesField"),
-    908: .same(proto: "visitRepeatedDoubleField"),
-    909: .same(proto: "visitRepeatedEnumField"),
-    910: .same(proto: "visitRepeatedFixed32Field"),
-    911: .same(proto: "visitRepeatedFixed64Field"),
-    912: .same(proto: "visitRepeatedFloatField"),
-    913: .same(proto: "visitRepeatedGroupField"),
-    914: .same(proto: "visitRepeatedInt32Field"),
-    915: .same(proto: "visitRepeatedInt64Field"),
-    916: .same(proto: "visitRepeatedMessageField"),
-    917: .same(proto: "visitRepeatedSFixed32Field"),
-    918: .same(proto: "visitRepeatedSFixed64Field"),
-    919: .same(proto: "visitRepeatedSInt32Field"),
-    920: .same(proto: "visitRepeatedSInt64Field"),
-    921: .same(proto: "visitRepeatedStringField"),
-    922: .same(proto: "visitRepeatedUInt32Field"),
-    923: .same(proto: "visitRepeatedUInt64Field"),
-    924: .same(proto: "visitSingular"),
-    925: .same(proto: "visitSingularBoolField"),
-    926: .same(proto: "visitSingularBytesField"),
-    927: .same(proto: "visitSingularDoubleField"),
-    928: .same(proto: "visitSingularEnumField"),
-    929: .same(proto: "visitSingularFixed32Field"),
-    930: .same(proto: "visitSingularFixed64Field"),
-    931: .same(proto: "visitSingularFloatField"),
-    932: .same(proto: "visitSingularGroupField"),
-    933: .same(proto: "visitSingularInt32Field"),
-    934: .same(proto: "visitSingularInt64Field"),
-    935: .same(proto: "visitSingularMessageField"),
-    936: .same(proto: "visitSingularSFixed32Field"),
-    937: .same(proto: "visitSingularSFixed64Field"),
-    938: .same(proto: "visitSingularSInt32Field"),
-    939: .same(proto: "visitSingularSInt64Field"),
-    940: .same(proto: "visitSingularStringField"),
-    941: .same(proto: "visitSingularUInt32Field"),
-    942: .same(proto: "visitSingularUInt64Field"),
-    943: .same(proto: "visitUnknown"),
-    944: .same(proto: "wasDecoded"),
-    945: .same(proto: "weak"),
-    946: .same(proto: "weakDependency"),
-    947: .same(proto: "where"),
-    948: .same(proto: "wireFormat"),
-    949: .same(proto: "with"),
-    950: .same(proto: "withUnsafeBytes"),
-    951: .same(proto: "withUnsafeMutableBytes"),
-    952: .same(proto: "work"),
-    953: .same(proto: "Wrapped"),
-    954: .same(proto: "WrappedType"),
-    955: .same(proto: "wrappedValue"),
-    956: .same(proto: "written"),
-    957: .same(proto: "yday"),
+    278: .same(proto: "escaping"),
+    279: .same(proto: "ExpressibleByArrayLiteral"),
+    280: .same(proto: "ExpressibleByDictionaryLiteral"),
+    281: .same(proto: "ext"),
+    282: .same(proto: "extDecoder"),
+    283: .same(proto: "extendedGraphemeClusterLiteral"),
+    284: .same(proto: "ExtendedGraphemeClusterLiteralType"),
+    285: .same(proto: "extendee"),
+    286: .same(proto: "ExtensibleMessage"),
+    287: .same(proto: "extension"),
+    288: .same(proto: "ExtensionField"),
+    289: .same(proto: "extensionFieldNumber"),
+    290: .same(proto: "extensionFields"),
+    291: .same(proto: "extensionFieldsAsMessageSet"),
+    292: .same(proto: "ExtensionFieldValueSet"),
+    293: .same(proto: "ExtensionMap"),
+    294: .same(proto: "extensionRange"),
+    295: .same(proto: "ExtensionRangeOptions"),
+    296: .same(proto: "extensions"),
+    297: .same(proto: "extras"),
+    298: .same(proto: "F"),
+    299: .same(proto: "false"),
+    300: .same(proto: "features"),
+    301: .same(proto: "FeatureSet"),
+    302: .same(proto: "FeatureSetDefaults"),
+    303: .same(proto: "FeatureSetEditionDefault"),
+    304: .same(proto: "field"),
+    305: .same(proto: "fieldData"),
+    306: .same(proto: "FieldDescriptorProto"),
+    307: .same(proto: "FieldMask"),
+    308: .same(proto: "fieldName"),
+    309: .same(proto: "fieldNameCount"),
+    310: .same(proto: "fieldNum"),
+    311: .same(proto: "fieldNumber"),
+    312: .same(proto: "fieldNumberForProto"),
+    313: .same(proto: "FieldOptions"),
+    314: .same(proto: "fieldPresence"),
+    315: .same(proto: "fields"),
+    316: .same(proto: "fieldSize"),
+    317: .same(proto: "FieldTag"),
+    318: .same(proto: "fieldType"),
+    319: .same(proto: "file"),
+    320: .same(proto: "FileDescriptorProto"),
+    321: .same(proto: "FileDescriptorSet"),
+    322: .same(proto: "fileName"),
+    323: .same(proto: "FileOptions"),
+    324: .same(proto: "filter"),
+    325: .same(proto: "final"),
+    326: .same(proto: "first"),
+    327: .same(proto: "firstItem"),
+    328: .same(proto: "Float"),
+    329: .same(proto: "floatLiteral"),
+    330: .same(proto: "FloatLiteralType"),
+    331: .same(proto: "FloatValue"),
+    332: .same(proto: "forMessageName"),
+    333: .same(proto: "formUnion"),
+    334: .same(proto: "forReadingFrom"),
+    335: .same(proto: "forTypeURL"),
+    336: .same(proto: "ForwardParser"),
+    337: .same(proto: "forWritingInto"),
+    338: .same(proto: "from"),
+    339: .same(proto: "fromAscii2"),
+    340: .same(proto: "fromAscii4"),
+    341: .same(proto: "fromByteOffset"),
+    342: .same(proto: "fromHexDigit"),
+    343: .same(proto: "fullName"),
+    344: .same(proto: "func"),
+    345: .same(proto: "G"),
+    346: .same(proto: "GeneratedCodeInfo"),
+    347: .same(proto: "get"),
+    348: .same(proto: "getExtensionValue"),
+    349: .same(proto: "getValue"),
+    350: .same(proto: "googleapis"),
+    351: .standard(proto: "Google_Protobuf_Any"),
+    352: .standard(proto: "Google_Protobuf_Api"),
+    353: .standard(proto: "Google_Protobuf_BoolValue"),
+    354: .standard(proto: "Google_Protobuf_BytesValue"),
+    355: .standard(proto: "Google_Protobuf_DescriptorProto"),
+    356: .standard(proto: "Google_Protobuf_DoubleValue"),
+    357: .standard(proto: "Google_Protobuf_Duration"),
+    358: .standard(proto: "Google_Protobuf_Edition"),
+    359: .standard(proto: "Google_Protobuf_Empty"),
+    360: .standard(proto: "Google_Protobuf_Enum"),
+    361: .standard(proto: "Google_Protobuf_EnumDescriptorProto"),
+    362: .standard(proto: "Google_Protobuf_EnumOptions"),
+    363: .standard(proto: "Google_Protobuf_EnumValue"),
+    364: .standard(proto: "Google_Protobuf_EnumValueDescriptorProto"),
+    365: .standard(proto: "Google_Protobuf_EnumValueOptions"),
+    366: .standard(proto: "Google_Protobuf_ExtensionRangeOptions"),
+    367: .standard(proto: "Google_Protobuf_FeatureSet"),
+    368: .standard(proto: "Google_Protobuf_FeatureSetDefaults"),
+    369: .standard(proto: "Google_Protobuf_Field"),
+    370: .standard(proto: "Google_Protobuf_FieldDescriptorProto"),
+    371: .standard(proto: "Google_Protobuf_FieldMask"),
+    372: .standard(proto: "Google_Protobuf_FieldOptions"),
+    373: .standard(proto: "Google_Protobuf_FileDescriptorProto"),
+    374: .standard(proto: "Google_Protobuf_FileDescriptorSet"),
+    375: .standard(proto: "Google_Protobuf_FileOptions"),
+    376: .standard(proto: "Google_Protobuf_FloatValue"),
+    377: .standard(proto: "Google_Protobuf_GeneratedCodeInfo"),
+    378: .standard(proto: "Google_Protobuf_Int32Value"),
+    379: .standard(proto: "Google_Protobuf_Int64Value"),
+    380: .standard(proto: "Google_Protobuf_ListValue"),
+    381: .standard(proto: "Google_Protobuf_MessageOptions"),
+    382: .standard(proto: "Google_Protobuf_Method"),
+    383: .standard(proto: "Google_Protobuf_MethodDescriptorProto"),
+    384: .standard(proto: "Google_Protobuf_MethodOptions"),
+    385: .standard(proto: "Google_Protobuf_Mixin"),
+    386: .standard(proto: "Google_Protobuf_NullValue"),
+    387: .standard(proto: "Google_Protobuf_OneofDescriptorProto"),
+    388: .standard(proto: "Google_Protobuf_OneofOptions"),
+    389: .standard(proto: "Google_Protobuf_Option"),
+    390: .standard(proto: "Google_Protobuf_ServiceDescriptorProto"),
+    391: .standard(proto: "Google_Protobuf_ServiceOptions"),
+    392: .standard(proto: "Google_Protobuf_SourceCodeInfo"),
+    393: .standard(proto: "Google_Protobuf_SourceContext"),
+    394: .standard(proto: "Google_Protobuf_StringValue"),
+    395: .standard(proto: "Google_Protobuf_Struct"),
+    396: .standard(proto: "Google_Protobuf_Syntax"),
+    397: .standard(proto: "Google_Protobuf_Timestamp"),
+    398: .standard(proto: "Google_Protobuf_Type"),
+    399: .standard(proto: "Google_Protobuf_UInt32Value"),
+    400: .standard(proto: "Google_Protobuf_UInt64Value"),
+    401: .standard(proto: "Google_Protobuf_UninterpretedOption"),
+    402: .standard(proto: "Google_Protobuf_Value"),
+    403: .same(proto: "goPackage"),
+    404: .same(proto: "group"),
+    405: .same(proto: "groupFieldNumberStack"),
+    406: .same(proto: "groupSize"),
+    407: .same(proto: "hadOneofValue"),
+    408: .same(proto: "handleConflictingOneOf"),
+    409: .same(proto: "hasAggregateValue"),
+    410: .same(proto: "hasAllowAlias"),
+    411: .same(proto: "hasBegin"),
+    412: .same(proto: "hasCcEnableArenas"),
+    413: .same(proto: "hasCcGenericServices"),
+    414: .same(proto: "hasClientStreaming"),
+    415: .same(proto: "hasCsharpNamespace"),
+    416: .same(proto: "hasCtype"),
+    417: .same(proto: "hasDebugRedact"),
+    418: .same(proto: "hasDefaultValue"),
+    419: .same(proto: "hasDeprecated"),
+    420: .same(proto: "hasDeprecatedLegacyJsonFieldConflicts"),
+    421: .same(proto: "hasDoubleValue"),
+    422: .same(proto: "hasEdition"),
+    423: .same(proto: "hasEnd"),
+    424: .same(proto: "hasEnumType"),
+    425: .same(proto: "hasExtendee"),
+    426: .same(proto: "hasExtensionValue"),
+    427: .same(proto: "hasFeatures"),
+    428: .same(proto: "hasFieldPresence"),
+    429: .same(proto: "hasFullName"),
+    430: .same(proto: "hasGoPackage"),
+    431: .same(proto: "hash"),
+    432: .same(proto: "Hashable"),
+    433: .same(proto: "hasher"),
+    434: .same(proto: "HashVisitor"),
+    435: .same(proto: "hasIdempotencyLevel"),
+    436: .same(proto: "hasIdentifierValue"),
+    437: .same(proto: "hasInputType"),
+    438: .same(proto: "hasIsExtension"),
+    439: .same(proto: "hasJavaGenerateEqualsAndHash"),
+    440: .same(proto: "hasJavaGenericServices"),
+    441: .same(proto: "hasJavaMultipleFiles"),
+    442: .same(proto: "hasJavaOuterClassname"),
+    443: .same(proto: "hasJavaPackage"),
+    444: .same(proto: "hasJavaStringCheckUtf8"),
+    445: .same(proto: "hasJsonFormat"),
+    446: .same(proto: "hasJsonName"),
+    447: .same(proto: "hasJstype"),
+    448: .same(proto: "hasLabel"),
+    449: .same(proto: "hasLazy"),
+    450: .same(proto: "hasLeadingComments"),
+    451: .same(proto: "hasMapEntry"),
+    452: .same(proto: "hasMaximumEdition"),
+    453: .same(proto: "hasMessageEncoding"),
+    454: .same(proto: "hasMessageSetWireFormat"),
+    455: .same(proto: "hasMinimumEdition"),
+    456: .same(proto: "hasName"),
+    457: .same(proto: "hasNamePart"),
+    458: .same(proto: "hasNegativeIntValue"),
+    459: .same(proto: "hasNoStandardDescriptorAccessor"),
+    460: .same(proto: "hasNumber"),
+    461: .same(proto: "hasObjcClassPrefix"),
+    462: .same(proto: "hasOneofIndex"),
+    463: .same(proto: "hasOptimizeFor"),
+    464: .same(proto: "hasOptions"),
+    465: .same(proto: "hasOutputType"),
+    466: .same(proto: "hasPackage"),
+    467: .same(proto: "hasPacked"),
+    468: .same(proto: "hasPhpClassPrefix"),
+    469: .same(proto: "hasPhpGenericServices"),
+    470: .same(proto: "hasPhpMetadataNamespace"),
+    471: .same(proto: "hasPhpNamespace"),
+    472: .same(proto: "hasPositiveIntValue"),
+    473: .same(proto: "hasProto3Optional"),
+    474: .same(proto: "hasPyGenericServices"),
+    475: .same(proto: "hasRepeated"),
+    476: .same(proto: "hasRepeatedFieldEncoding"),
+    477: .same(proto: "hasReserved"),
+    478: .same(proto: "hasRetention"),
+    479: .same(proto: "hasRubyPackage"),
+    480: .same(proto: "hasSemantic"),
+    481: .same(proto: "hasServerStreaming"),
+    482: .same(proto: "hasSourceCodeInfo"),
+    483: .same(proto: "hasSourceContext"),
+    484: .same(proto: "hasSourceFile"),
+    485: .same(proto: "hasStart"),
+    486: .same(proto: "hasStringValue"),
+    487: .same(proto: "hasSwiftPrefix"),
+    488: .same(proto: "hasSyntax"),
+    489: .same(proto: "hasTrailingComments"),
+    490: .same(proto: "hasType"),
+    491: .same(proto: "hasTypeName"),
+    492: .same(proto: "hasUnverifiedLazy"),
+    493: .same(proto: "hasUtf8Validation"),
+    494: .same(proto: "hasValue"),
+    495: .same(proto: "hasVerification"),
+    496: .same(proto: "hasWeak"),
+    497: .same(proto: "hour"),
+    498: .same(proto: "i"),
+    499: .same(proto: "idempotencyLevel"),
+    500: .same(proto: "identifierValue"),
+    501: .same(proto: "if"),
+    502: .same(proto: "ignoreUnknownFields"),
+    503: .same(proto: "index"),
+    504: .same(proto: "init"),
+    505: .same(proto: "inout"),
+    506: .same(proto: "inputType"),
+    507: .same(proto: "insert"),
+    508: .same(proto: "Int"),
+    509: .same(proto: "Int32"),
+    510: .same(proto: "Int32Value"),
+    511: .same(proto: "Int64"),
+    512: .same(proto: "Int64Value"),
+    513: .same(proto: "Int8"),
+    514: .same(proto: "integerLiteral"),
+    515: .same(proto: "IntegerLiteralType"),
+    516: .same(proto: "intern"),
+    517: .same(proto: "Internal"),
+    518: .same(proto: "InternalState"),
+    519: .same(proto: "into"),
+    520: .same(proto: "ints"),
+    521: .same(proto: "isA"),
+    522: .same(proto: "isEqual"),
+    523: .same(proto: "isEqualTo"),
+    524: .same(proto: "isExtension"),
+    525: .same(proto: "isInitialized"),
+    526: .same(proto: "isNegative"),
+    527: .same(proto: "isUnset"),
+    528: .same(proto: "itemTagsEncodedSize"),
+    529: .same(proto: "iterator"),
+    530: .same(proto: "javaGenerateEqualsAndHash"),
+    531: .same(proto: "javaGenericServices"),
+    532: .same(proto: "javaMultipleFiles"),
+    533: .same(proto: "javaOuterClassname"),
+    534: .same(proto: "javaPackage"),
+    535: .same(proto: "javaStringCheckUtf8"),
+    536: .same(proto: "JSONDecoder"),
+    537: .same(proto: "JSONDecodingError"),
+    538: .same(proto: "JSONDecodingOptions"),
+    539: .same(proto: "jsonEncoder"),
+    540: .same(proto: "JSONEncodingError"),
+    541: .same(proto: "JSONEncodingOptions"),
+    542: .same(proto: "JSONEncodingVisitor"),
+    543: .same(proto: "jsonFormat"),
+    544: .same(proto: "JSONMapEncodingVisitor"),
+    545: .same(proto: "jsonName"),
+    546: .same(proto: "jsonPath"),
+    547: .same(proto: "jsonPaths"),
+    548: .same(proto: "JSONScanner"),
+    549: .same(proto: "jsonString"),
+    550: .same(proto: "jsonText"),
+    551: .same(proto: "jsonUTF8Bytes"),
+    552: .same(proto: "jsonUTF8Data"),
+    553: .same(proto: "jstype"),
+    554: .same(proto: "k"),
+    555: .same(proto: "kChunkSize"),
+    556: .same(proto: "Key"),
+    557: .same(proto: "keyField"),
+    558: .same(proto: "keyFieldOpt"),
+    559: .same(proto: "KeyType"),
+    560: .same(proto: "kind"),
+    561: .same(proto: "l"),
+    562: .same(proto: "label"),
+    563: .same(proto: "lazy"),
+    564: .same(proto: "leadingComments"),
+    565: .same(proto: "leadingDetachedComments"),
+    566: .same(proto: "length"),
+    567: .same(proto: "lessThan"),
+    568: .same(proto: "let"),
+    569: .same(proto: "lhs"),
+    570: .same(proto: "list"),
+    571: .same(proto: "listOfMessages"),
+    572: .same(proto: "listValue"),
+    573: .same(proto: "littleEndian"),
+    574: .same(proto: "littleEndianBytes"),
+    575: .same(proto: "load"),
+    576: .same(proto: "localHasher"),
+    577: .same(proto: "location"),
+    578: .same(proto: "M"),
+    579: .same(proto: "major"),
+    580: .same(proto: "makeAsyncIterator"),
+    581: .same(proto: "makeIterator"),
+    582: .same(proto: "map"),
+    583: .same(proto: "mapEntry"),
+    584: .same(proto: "MapKeyType"),
+    585: .same(proto: "mapToMessages"),
+    586: .same(proto: "MapValueType"),
+    587: .same(proto: "mapVisitor"),
+    588: .same(proto: "maximumEdition"),
+    589: .same(proto: "mdayStart"),
+    590: .same(proto: "merge"),
+    591: .same(proto: "message"),
+    592: .same(proto: "messageDepthLimit"),
+    593: .same(proto: "messageEncoding"),
+    594: .same(proto: "MessageExtension"),
+    595: .same(proto: "MessageImplementationBase"),
+    596: .same(proto: "MessageOptions"),
+    597: .same(proto: "MessageSet"),
+    598: .same(proto: "messageSetWireFormat"),
+    599: .same(proto: "messageSize"),
+    600: .same(proto: "messageType"),
+    601: .same(proto: "Method"),
+    602: .same(proto: "MethodDescriptorProto"),
+    603: .same(proto: "MethodOptions"),
+    604: .same(proto: "methods"),
+    605: .same(proto: "min"),
+    606: .same(proto: "minimumEdition"),
+    607: .same(proto: "minor"),
+    608: .same(proto: "Mixin"),
+    609: .same(proto: "mixins"),
+    610: .same(proto: "modifier"),
+    611: .same(proto: "modify"),
+    612: .same(proto: "month"),
+    613: .same(proto: "msgExtension"),
+    614: .same(proto: "mutating"),
+    615: .same(proto: "n"),
+    616: .same(proto: "name"),
+    617: .same(proto: "NameDescription"),
+    618: .same(proto: "NameMap"),
+    619: .same(proto: "NamePart"),
+    620: .same(proto: "names"),
+    621: .same(proto: "nanos"),
+    622: .same(proto: "negativeIntValue"),
+    623: .same(proto: "nestedType"),
+    624: .same(proto: "newL"),
+    625: .same(proto: "newList"),
+    626: .same(proto: "newValue"),
+    627: .same(proto: "next"),
+    628: .same(proto: "nextByte"),
+    629: .same(proto: "nextFieldNumber"),
+    630: .same(proto: "nextVarInt"),
+    631: .same(proto: "nil"),
+    632: .same(proto: "nilLiteral"),
+    633: .same(proto: "noStandardDescriptorAccessor"),
+    634: .same(proto: "nullValue"),
+    635: .same(proto: "number"),
+    636: .same(proto: "numberValue"),
+    637: .same(proto: "objcClassPrefix"),
+    638: .same(proto: "of"),
+    639: .same(proto: "oneOf"),
+    640: .same(proto: "oneofDecl"),
+    641: .same(proto: "OneofDescriptorProto"),
+    642: .same(proto: "oneofIndex"),
+    643: .same(proto: "OneofOptions"),
+    644: .same(proto: "oneofs"),
+    645: .standard(proto: "OneOf_Kind"),
+    646: .same(proto: "optimizeFor"),
+    647: .same(proto: "OptimizeMode"),
+    648: .same(proto: "Option"),
+    649: .same(proto: "OptionalEnumExtensionField"),
+    650: .same(proto: "OptionalExtensionField"),
+    651: .same(proto: "OptionalGroupExtensionField"),
+    652: .same(proto: "OptionalMessageExtensionField"),
+    653: .same(proto: "OptionRetention"),
+    654: .same(proto: "options"),
+    655: .same(proto: "OptionTargetType"),
+    656: .same(proto: "other"),
+    657: .same(proto: "others"),
+    658: .same(proto: "out"),
+    659: .same(proto: "outputType"),
+    660: .same(proto: "p"),
+    661: .same(proto: "package"),
+    662: .same(proto: "packed"),
+    663: .same(proto: "packedBool"),
+    664: .same(proto: "packedDouble"),
+    665: .same(proto: "packedEnum"),
+    666: .same(proto: "PackedEnumExtensionField"),
+    667: .same(proto: "PackedExtensionField"),
+    668: .same(proto: "packedFixed32"),
+    669: .same(proto: "packedFixed64"),
+    670: .same(proto: "packedFloat"),
+    671: .same(proto: "packedInt32"),
+    672: .same(proto: "packedInt64"),
+    673: .same(proto: "packedSFixed32"),
+    674: .same(proto: "packedSFixed64"),
+    675: .same(proto: "packedSInt32"),
+    676: .same(proto: "packedSInt64"),
+    677: .same(proto: "packedUInt32"),
+    678: .same(proto: "packedUInt64"),
+    679: .same(proto: "padding"),
+    680: .same(proto: "parent"),
+    681: .same(proto: "parse"),
+    682: .same(proto: "path"),
+    683: .same(proto: "paths"),
+    684: .same(proto: "payload"),
+    685: .same(proto: "payloadSize"),
+    686: .same(proto: "phpClassPrefix"),
+    687: .same(proto: "phpGenericServices"),
+    688: .same(proto: "phpMetadataNamespace"),
+    689: .same(proto: "phpNamespace"),
+    690: .same(proto: "pos"),
+    691: .same(proto: "positiveIntValue"),
+    692: .same(proto: "prefix"),
+    693: .same(proto: "preserveProtoFieldNames"),
+    694: .same(proto: "preTraverse"),
+    695: .same(proto: "printUnknownFields"),
+    696: .same(proto: "proto2"),
+    697: .same(proto: "proto3DefaultValue"),
+    698: .same(proto: "proto3Optional"),
+    699: .same(proto: "ProtobufAPIVersionCheck"),
+    700: .standard(proto: "ProtobufAPIVersion_3"),
+    701: .same(proto: "ProtobufBool"),
+    702: .same(proto: "ProtobufBytes"),
+    703: .same(proto: "ProtobufDouble"),
+    704: .same(proto: "ProtobufEnumMap"),
+    705: .same(proto: "protobufExtension"),
+    706: .same(proto: "ProtobufFixed32"),
+    707: .same(proto: "ProtobufFixed64"),
+    708: .same(proto: "ProtobufFloat"),
+    709: .same(proto: "ProtobufInt32"),
+    710: .same(proto: "ProtobufInt64"),
+    711: .same(proto: "ProtobufMap"),
+    712: .same(proto: "ProtobufMessageMap"),
+    713: .same(proto: "ProtobufSFixed32"),
+    714: .same(proto: "ProtobufSFixed64"),
+    715: .same(proto: "ProtobufSInt32"),
+    716: .same(proto: "ProtobufSInt64"),
+    717: .same(proto: "ProtobufString"),
+    718: .same(proto: "ProtobufUInt32"),
+    719: .same(proto: "ProtobufUInt64"),
+    720: .standard(proto: "protobuf_extensionFieldValues"),
+    721: .standard(proto: "protobuf_fieldNumber"),
+    722: .standard(proto: "protobuf_generated_isEqualTo"),
+    723: .standard(proto: "protobuf_nameMap"),
+    724: .standard(proto: "protobuf_newField"),
+    725: .standard(proto: "protobuf_package"),
+    726: .same(proto: "protocol"),
+    727: .same(proto: "protoFieldName"),
+    728: .same(proto: "protoMessageName"),
+    729: .same(proto: "ProtoNameProviding"),
+    730: .same(proto: "protoPaths"),
+    731: .same(proto: "public"),
+    732: .same(proto: "publicDependency"),
+    733: .same(proto: "putBoolValue"),
+    734: .same(proto: "putBytesValue"),
+    735: .same(proto: "putDoubleValue"),
+    736: .same(proto: "putEnumValue"),
+    737: .same(proto: "putFixedUInt32"),
+    738: .same(proto: "putFixedUInt64"),
+    739: .same(proto: "putFloatValue"),
+    740: .same(proto: "putInt64"),
+    741: .same(proto: "putStringValue"),
+    742: .same(proto: "putUInt64"),
+    743: .same(proto: "putUInt64Hex"),
+    744: .same(proto: "putVarInt"),
+    745: .same(proto: "putZigZagVarInt"),
+    746: .same(proto: "pyGenericServices"),
+    747: .same(proto: "R"),
+    748: .same(proto: "rawChars"),
+    749: .same(proto: "RawRepresentable"),
+    750: .same(proto: "RawValue"),
+    751: .same(proto: "read4HexDigits"),
+    752: .same(proto: "readBytes"),
+    753: .same(proto: "register"),
+    754: .same(proto: "repeated"),
+    755: .same(proto: "repeatedBool"),
+    756: .same(proto: "repeatedBytes"),
+    757: .same(proto: "repeatedDouble"),
+    758: .same(proto: "repeatedEnum"),
+    759: .same(proto: "RepeatedEnumExtensionField"),
+    760: .same(proto: "RepeatedExtensionField"),
+    761: .same(proto: "repeatedFieldEncoding"),
+    762: .same(proto: "repeatedFixed32"),
+    763: .same(proto: "repeatedFixed64"),
+    764: .same(proto: "repeatedFloat"),
+    765: .same(proto: "repeatedGroup"),
+    766: .same(proto: "RepeatedGroupExtensionField"),
+    767: .same(proto: "repeatedInt32"),
+    768: .same(proto: "repeatedInt64"),
+    769: .same(proto: "repeatedMessage"),
+    770: .same(proto: "RepeatedMessageExtensionField"),
+    771: .same(proto: "repeatedSFixed32"),
+    772: .same(proto: "repeatedSFixed64"),
+    773: .same(proto: "repeatedSInt32"),
+    774: .same(proto: "repeatedSInt64"),
+    775: .same(proto: "repeatedString"),
+    776: .same(proto: "repeatedUInt32"),
+    777: .same(proto: "repeatedUInt64"),
+    778: .same(proto: "repeating"),
+    779: .same(proto: "requestStreaming"),
+    780: .same(proto: "requestTypeURL"),
+    781: .same(proto: "requiredSize"),
+    782: .same(proto: "responseStreaming"),
+    783: .same(proto: "responseTypeURL"),
+    784: .same(proto: "result"),
+    785: .same(proto: "retention"),
+    786: .same(proto: "rethrows"),
+    787: .same(proto: "return"),
+    788: .same(proto: "ReturnType"),
+    789: .same(proto: "revision"),
+    790: .same(proto: "rhs"),
+    791: .same(proto: "root"),
+    792: .same(proto: "rubyPackage"),
+    793: .same(proto: "s"),
+    794: .same(proto: "sawBackslash"),
+    795: .same(proto: "sawSection4Characters"),
+    796: .same(proto: "sawSection5Characters"),
+    797: .same(proto: "scanner"),
+    798: .same(proto: "seconds"),
+    799: .same(proto: "self"),
+    800: .same(proto: "semantic"),
+    801: .same(proto: "Sendable"),
+    802: .same(proto: "separator"),
+    803: .same(proto: "serialize"),
+    804: .same(proto: "serializedBytes"),
+    805: .same(proto: "serializedData"),
+    806: .same(proto: "serializedSize"),
+    807: .same(proto: "serverStreaming"),
+    808: .same(proto: "service"),
+    809: .same(proto: "ServiceDescriptorProto"),
+    810: .same(proto: "ServiceOptions"),
+    811: .same(proto: "set"),
+    812: .same(proto: "setExtensionValue"),
+    813: .same(proto: "shift"),
+    814: .same(proto: "SimpleExtensionMap"),
+    815: .same(proto: "singularBool"),
+    816: .same(proto: "singularBytes"),
+    817: .same(proto: "singularDouble"),
+    818: .same(proto: "singularEnum"),
+    819: .same(proto: "singularFixed32"),
+    820: .same(proto: "singularFixed64"),
+    821: .same(proto: "singularFloat"),
+    822: .same(proto: "singularGroup"),
+    823: .same(proto: "singularInt32"),
+    824: .same(proto: "singularInt64"),
+    825: .same(proto: "singularMessage"),
+    826: .same(proto: "singularSFixed32"),
+    827: .same(proto: "singularSFixed64"),
+    828: .same(proto: "singularSInt32"),
+    829: .same(proto: "singularSInt64"),
+    830: .same(proto: "singularString"),
+    831: .same(proto: "singularUInt32"),
+    832: .same(proto: "singularUInt64"),
+    833: .same(proto: "size"),
+    834: .same(proto: "sizer"),
+    835: .same(proto: "source"),
+    836: .same(proto: "sourceCodeInfo"),
+    837: .same(proto: "sourceContext"),
+    838: .same(proto: "sourceEncoding"),
+    839: .same(proto: "sourceFile"),
+    840: .same(proto: "span"),
+    841: .same(proto: "split"),
+    842: .same(proto: "start"),
+    843: .same(proto: "startArray"),
+    844: .same(proto: "startArrayObject"),
+    845: .same(proto: "startField"),
+    846: .same(proto: "startIndex"),
+    847: .same(proto: "startMessageField"),
+    848: .same(proto: "startObject"),
+    849: .same(proto: "startRegularField"),
+    850: .same(proto: "state"),
+    851: .same(proto: "static"),
+    852: .same(proto: "StaticString"),
+    853: .same(proto: "storage"),
+    854: .same(proto: "String"),
+    855: .same(proto: "stringLiteral"),
+    856: .same(proto: "StringLiteralType"),
+    857: .same(proto: "stringResult"),
+    858: .same(proto: "stringValue"),
+    859: .same(proto: "struct"),
+    860: .same(proto: "structValue"),
+    861: .same(proto: "subDecoder"),
+    862: .same(proto: "subscript"),
+    863: .same(proto: "subVisitor"),
+    864: .same(proto: "Swift"),
+    865: .same(proto: "swiftPrefix"),
+    866: .same(proto: "SwiftProtobufContiguousBytes"),
+    867: .same(proto: "syntax"),
+    868: .same(proto: "T"),
+    869: .same(proto: "tag"),
+    870: .same(proto: "targets"),
+    871: .same(proto: "terminator"),
+    872: .same(proto: "testDecoder"),
+    873: .same(proto: "text"),
+    874: .same(proto: "textDecoder"),
+    875: .same(proto: "TextFormatDecoder"),
+    876: .same(proto: "TextFormatDecodingError"),
+    877: .same(proto: "TextFormatDecodingOptions"),
+    878: .same(proto: "TextFormatEncodingOptions"),
+    879: .same(proto: "TextFormatEncodingVisitor"),
+    880: .same(proto: "textFormatString"),
+    881: .same(proto: "throwOrIgnore"),
+    882: .same(proto: "throws"),
+    883: .same(proto: "timeInterval"),
+    884: .same(proto: "timeIntervalSince1970"),
+    885: .same(proto: "timeIntervalSinceReferenceDate"),
+    886: .same(proto: "Timestamp"),
+    887: .same(proto: "toConcrete"),
+    888: .same(proto: "total"),
+    889: .same(proto: "totalArrayDepth"),
+    890: .same(proto: "totalSize"),
+    891: .same(proto: "trailingComments"),
+    892: .same(proto: "traverse"),
+    893: .same(proto: "true"),
+    894: .same(proto: "try"),
+    895: .same(proto: "type"),
+    896: .same(proto: "typealias"),
+    897: .same(proto: "TypeEnum"),
+    898: .same(proto: "typeName"),
+    899: .same(proto: "typePrefix"),
+    900: .same(proto: "typeStart"),
+    901: .same(proto: "typeUnknown"),
+    902: .same(proto: "typeURL"),
+    903: .same(proto: "UInt32"),
+    904: .same(proto: "UInt32Value"),
+    905: .same(proto: "UInt64"),
+    906: .same(proto: "UInt64Value"),
+    907: .same(proto: "UInt8"),
+    908: .same(proto: "unchecked"),
+    909: .same(proto: "unicodeScalarLiteral"),
+    910: .same(proto: "UnicodeScalarLiteralType"),
+    911: .same(proto: "unicodeScalars"),
+    912: .same(proto: "UnicodeScalarView"),
+    913: .same(proto: "uninterpretedOption"),
+    914: .same(proto: "union"),
+    915: .same(proto: "uniqueStorage"),
+    916: .same(proto: "unknown"),
+    917: .same(proto: "unknownFields"),
+    918: .same(proto: "UnknownStorage"),
+    919: .same(proto: "unpackTo"),
+    920: .same(proto: "UnsafeBufferPointer"),
+    921: .same(proto: "UnsafeMutablePointer"),
+    922: .same(proto: "UnsafeMutableRawBufferPointer"),
+    923: .same(proto: "UnsafeRawBufferPointer"),
+    924: .same(proto: "UnsafeRawPointer"),
+    925: .same(proto: "unverifiedLazy"),
+    926: .same(proto: "updatedOptions"),
+    927: .same(proto: "url"),
+    928: .same(proto: "useDeterministicOrdering"),
+    929: .same(proto: "utf8"),
+    930: .same(proto: "utf8Ptr"),
+    931: .same(proto: "utf8ToDouble"),
+    932: .same(proto: "utf8Validation"),
+    933: .same(proto: "UTF8View"),
+    934: .same(proto: "v"),
+    935: .same(proto: "value"),
+    936: .same(proto: "valueField"),
+    937: .same(proto: "values"),
+    938: .same(proto: "ValueType"),
+    939: .same(proto: "var"),
+    940: .same(proto: "verification"),
+    941: .same(proto: "VerificationState"),
+    942: .same(proto: "Version"),
+    943: .same(proto: "versionString"),
+    944: .same(proto: "visitExtensionFields"),
+    945: .same(proto: "visitExtensionFieldsAsMessageSet"),
+    946: .same(proto: "visitMapField"),
+    947: .same(proto: "visitor"),
+    948: .same(proto: "visitPacked"),
+    949: .same(proto: "visitPackedBoolField"),
+    950: .same(proto: "visitPackedDoubleField"),
+    951: .same(proto: "visitPackedEnumField"),
+    952: .same(proto: "visitPackedFixed32Field"),
+    953: .same(proto: "visitPackedFixed64Field"),
+    954: .same(proto: "visitPackedFloatField"),
+    955: .same(proto: "visitPackedInt32Field"),
+    956: .same(proto: "visitPackedInt64Field"),
+    957: .same(proto: "visitPackedSFixed32Field"),
+    958: .same(proto: "visitPackedSFixed64Field"),
+    959: .same(proto: "visitPackedSInt32Field"),
+    960: .same(proto: "visitPackedSInt64Field"),
+    961: .same(proto: "visitPackedUInt32Field"),
+    962: .same(proto: "visitPackedUInt64Field"),
+    963: .same(proto: "visitRepeated"),
+    964: .same(proto: "visitRepeatedBoolField"),
+    965: .same(proto: "visitRepeatedBytesField"),
+    966: .same(proto: "visitRepeatedDoubleField"),
+    967: .same(proto: "visitRepeatedEnumField"),
+    968: .same(proto: "visitRepeatedFixed32Field"),
+    969: .same(proto: "visitRepeatedFixed64Field"),
+    970: .same(proto: "visitRepeatedFloatField"),
+    971: .same(proto: "visitRepeatedGroupField"),
+    972: .same(proto: "visitRepeatedInt32Field"),
+    973: .same(proto: "visitRepeatedInt64Field"),
+    974: .same(proto: "visitRepeatedMessageField"),
+    975: .same(proto: "visitRepeatedSFixed32Field"),
+    976: .same(proto: "visitRepeatedSFixed64Field"),
+    977: .same(proto: "visitRepeatedSInt32Field"),
+    978: .same(proto: "visitRepeatedSInt64Field"),
+    979: .same(proto: "visitRepeatedStringField"),
+    980: .same(proto: "visitRepeatedUInt32Field"),
+    981: .same(proto: "visitRepeatedUInt64Field"),
+    982: .same(proto: "visitSingular"),
+    983: .same(proto: "visitSingularBoolField"),
+    984: .same(proto: "visitSingularBytesField"),
+    985: .same(proto: "visitSingularDoubleField"),
+    986: .same(proto: "visitSingularEnumField"),
+    987: .same(proto: "visitSingularFixed32Field"),
+    988: .same(proto: "visitSingularFixed64Field"),
+    989: .same(proto: "visitSingularFloatField"),
+    990: .same(proto: "visitSingularGroupField"),
+    991: .same(proto: "visitSingularInt32Field"),
+    992: .same(proto: "visitSingularInt64Field"),
+    993: .same(proto: "visitSingularMessageField"),
+    994: .same(proto: "visitSingularSFixed32Field"),
+    995: .same(proto: "visitSingularSFixed64Field"),
+    996: .same(proto: "visitSingularSInt32Field"),
+    997: .same(proto: "visitSingularSInt64Field"),
+    998: .same(proto: "visitSingularStringField"),
+    999: .same(proto: "visitSingularUInt32Field"),
+    1000: .same(proto: "visitSingularUInt64Field"),
+    1001: .same(proto: "visitUnknown"),
+    1002: .same(proto: "wasDecoded"),
+    1003: .same(proto: "weak"),
+    1004: .same(proto: "weakDependency"),
+    1005: .same(proto: "where"),
+    1006: .same(proto: "wireFormat"),
+    1007: .same(proto: "with"),
+    1008: .same(proto: "withUnsafeBytes"),
+    1009: .same(proto: "withUnsafeMutableBytes"),
+    1010: .same(proto: "work"),
+    1011: .same(proto: "Wrapped"),
+    1012: .same(proto: "WrappedType"),
+    1013: .same(proto: "wrappedValue"),
+    1014: .same(proto: "written"),
+    1015: .same(proto: "yday"),
   ]
 
   fileprivate class _StorageClass {
@@ -6065,6 +6413,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     var _enumValueOptions: Int32 = 0
     var _equatable: Int32 = 0
     var _error: Int32 = 0
+    var _escaping: Int32 = 0
     var _expressibleByArrayLiteral: Int32 = 0
     var _expressibleByDictionaryLiteral: Int32 = 0
     var _ext: Int32 = 0
@@ -6076,6 +6425,8 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     var _extension: Int32 = 0
     var _extensionField: Int32 = 0
     var _extensionFieldNumber: Int32 = 0
+    var _extensionFields: Int32 = 0
+    var _extensionFieldsAsMessageSet: Int32 = 0
     var _extensionFieldValueSet: Int32 = 0
     var _extensionMap: Int32 = 0
     var _extensionRange: Int32 = 0
@@ -6133,6 +6484,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     var _generatedCodeInfo: Int32 = 0
     var _get: Int32 = 0
     var _getExtensionValue: Int32 = 0
+    var _getValue: Int32 = 0
     var _googleapis: Int32 = 0
     var _googleProtobufAny: Int32 = 0
     var _googleProtobufApi: Int32 = 0
@@ -6310,6 +6662,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     var _isExtension: Int32 = 0
     var _isInitialized_p: Int32 = 0
     var _isNegative: Int32 = 0
+    var _isUnset: Int32 = 0
     var _itemTagsEncodedSize: Int32 = 0
     var _iterator: Int32 = 0
     var _javaGenerateEqualsAndHash: Int32 = 0
@@ -6364,6 +6717,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     var _major: Int32 = 0
     var _makeAsyncIterator: Int32 = 0
     var _makeIterator: Int32 = 0
+    var _map: Int32 = 0
     var _mapEntry: Int32 = 0
     var _mapKeyType: Int32 = 0
     var _mapToMessages: Int32 = 0
@@ -6420,6 +6774,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     var _numberValue: Int32 = 0
     var _objcClassPrefix: Int32 = 0
     var _of: Int32 = 0
+    var _oneOf: Int32 = 0
     var _oneofDecl: Int32 = 0
     var _oneofDescriptorProto: Int32 = 0
     var _oneofIndex: Int32 = 0
@@ -6443,8 +6798,22 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     var _p: Int32 = 0
     var _package: Int32 = 0
     var _packed: Int32 = 0
+    var _packedBool: Int32 = 0
+    var _packedDouble: Int32 = 0
+    var _packedEnum: Int32 = 0
     var _packedEnumExtensionField: Int32 = 0
     var _packedExtensionField: Int32 = 0
+    var _packedFixed32: Int32 = 0
+    var _packedFixed64: Int32 = 0
+    var _packedFloat: Int32 = 0
+    var _packedInt32: Int32 = 0
+    var _packedInt64: Int32 = 0
+    var _packedSfixed32: Int32 = 0
+    var _packedSfixed64: Int32 = 0
+    var _packedSint32: Int32 = 0
+    var _packedSint64: Int32 = 0
+    var _packedUint32: Int32 = 0
+    var _packedUint64: Int32 = 0
     var _padding: Int32 = 0
     var _parent: Int32 = 0
     var _parse: Int32 = 0
@@ -6521,11 +6890,29 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     var _readBytes: Int32 = 0
     var _register: Int32 = 0
     var _repeated: Int32 = 0
+    var _repeatedBool: Int32 = 0
+    var _repeatedBytes: Int32 = 0
+    var _repeatedDouble: Int32 = 0
+    var _repeatedEnum: Int32 = 0
     var _repeatedEnumExtensionField: Int32 = 0
     var _repeatedExtensionField: Int32 = 0
     var _repeatedFieldEncoding: Int32 = 0
+    var _repeatedFixed32: Int32 = 0
+    var _repeatedFixed64: Int32 = 0
+    var _repeatedFloat: Int32 = 0
+    var _repeatedGroup: Int32 = 0
     var _repeatedGroupExtensionField: Int32 = 0
+    var _repeatedInt32: Int32 = 0
+    var _repeatedInt64: Int32 = 0
+    var _repeatedMessage: Int32 = 0
     var _repeatedMessageExtensionField: Int32 = 0
+    var _repeatedSfixed32: Int32 = 0
+    var _repeatedSfixed64: Int32 = 0
+    var _repeatedSint32: Int32 = 0
+    var _repeatedSint64: Int32 = 0
+    var _repeatedString: Int32 = 0
+    var _repeatedUint32: Int32 = 0
+    var _repeatedUint64: Int32 = 0
     var _repeating: Int32 = 0
     var _requestStreaming: Int32 = 0
     var _requestTypeURL: Int32 = 0
@@ -6563,6 +6950,24 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     var _setExtensionValue: Int32 = 0
     var _shift: Int32 = 0
     var _simpleExtensionMap: Int32 = 0
+    var _singularBool: Int32 = 0
+    var _singularBytes: Int32 = 0
+    var _singularDouble: Int32 = 0
+    var _singularEnum: Int32 = 0
+    var _singularFixed32: Int32 = 0
+    var _singularFixed64: Int32 = 0
+    var _singularFloat: Int32 = 0
+    var _singularGroup: Int32 = 0
+    var _singularInt32: Int32 = 0
+    var _singularInt64: Int32 = 0
+    var _singularMessage: Int32 = 0
+    var _singularSfixed32: Int32 = 0
+    var _singularSfixed64: Int32 = 0
+    var _singularSint32: Int32 = 0
+    var _singularSint64: Int32 = 0
+    var _singularString: Int32 = 0
+    var _singularUint32: Int32 = 0
+    var _singularUint64: Int32 = 0
     var _size: Int32 = 0
     var _sizer: Int32 = 0
     var _source: Int32 = 0
@@ -6617,6 +7022,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
     var _timeIntervalSince1970: Int32 = 0
     var _timeIntervalSinceReferenceDate: Int32 = 0
     var _timestamp: Int32 = 0
+    var _toConcrete: Int32 = 0
     var _total: Int32 = 0
     var _totalArrayDepth: Int32 = 0
     var _totalSize: Int32 = 0
@@ -7028,6 +7434,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
       _enumValueOptions = source._enumValueOptions
       _equatable = source._equatable
       _error = source._error
+      _escaping = source._escaping
       _expressibleByArrayLiteral = source._expressibleByArrayLiteral
       _expressibleByDictionaryLiteral = source._expressibleByDictionaryLiteral
       _ext = source._ext
@@ -7039,6 +7446,8 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
       _extension = source._extension
       _extensionField = source._extensionField
       _extensionFieldNumber = source._extensionFieldNumber
+      _extensionFields = source._extensionFields
+      _extensionFieldsAsMessageSet = source._extensionFieldsAsMessageSet
       _extensionFieldValueSet = source._extensionFieldValueSet
       _extensionMap = source._extensionMap
       _extensionRange = source._extensionRange
@@ -7096,6 +7505,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
       _generatedCodeInfo = source._generatedCodeInfo
       _get = source._get
       _getExtensionValue = source._getExtensionValue
+      _getValue = source._getValue
       _googleapis = source._googleapis
       _googleProtobufAny = source._googleProtobufAny
       _googleProtobufApi = source._googleProtobufApi
@@ -7273,6 +7683,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
       _isExtension = source._isExtension
       _isInitialized_p = source._isInitialized_p
       _isNegative = source._isNegative
+      _isUnset = source._isUnset
       _itemTagsEncodedSize = source._itemTagsEncodedSize
       _iterator = source._iterator
       _javaGenerateEqualsAndHash = source._javaGenerateEqualsAndHash
@@ -7327,6 +7738,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
       _major = source._major
       _makeAsyncIterator = source._makeAsyncIterator
       _makeIterator = source._makeIterator
+      _map = source._map
       _mapEntry = source._mapEntry
       _mapKeyType = source._mapKeyType
       _mapToMessages = source._mapToMessages
@@ -7383,6 +7795,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
       _numberValue = source._numberValue
       _objcClassPrefix = source._objcClassPrefix
       _of = source._of
+      _oneOf = source._oneOf
       _oneofDecl = source._oneofDecl
       _oneofDescriptorProto = source._oneofDescriptorProto
       _oneofIndex = source._oneofIndex
@@ -7406,8 +7819,22 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
       _p = source._p
       _package = source._package
       _packed = source._packed
+      _packedBool = source._packedBool
+      _packedDouble = source._packedDouble
+      _packedEnum = source._packedEnum
       _packedEnumExtensionField = source._packedEnumExtensionField
       _packedExtensionField = source._packedExtensionField
+      _packedFixed32 = source._packedFixed32
+      _packedFixed64 = source._packedFixed64
+      _packedFloat = source._packedFloat
+      _packedInt32 = source._packedInt32
+      _packedInt64 = source._packedInt64
+      _packedSfixed32 = source._packedSfixed32
+      _packedSfixed64 = source._packedSfixed64
+      _packedSint32 = source._packedSint32
+      _packedSint64 = source._packedSint64
+      _packedUint32 = source._packedUint32
+      _packedUint64 = source._packedUint64
       _padding = source._padding
       _parent = source._parent
       _parse = source._parse
@@ -7484,11 +7911,29 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
       _readBytes = source._readBytes
       _register = source._register
       _repeated = source._repeated
+      _repeatedBool = source._repeatedBool
+      _repeatedBytes = source._repeatedBytes
+      _repeatedDouble = source._repeatedDouble
+      _repeatedEnum = source._repeatedEnum
       _repeatedEnumExtensionField = source._repeatedEnumExtensionField
       _repeatedExtensionField = source._repeatedExtensionField
       _repeatedFieldEncoding = source._repeatedFieldEncoding
+      _repeatedFixed32 = source._repeatedFixed32
+      _repeatedFixed64 = source._repeatedFixed64
+      _repeatedFloat = source._repeatedFloat
+      _repeatedGroup = source._repeatedGroup
       _repeatedGroupExtensionField = source._repeatedGroupExtensionField
+      _repeatedInt32 = source._repeatedInt32
+      _repeatedInt64 = source._repeatedInt64
+      _repeatedMessage = source._repeatedMessage
       _repeatedMessageExtensionField = source._repeatedMessageExtensionField
+      _repeatedSfixed32 = source._repeatedSfixed32
+      _repeatedSfixed64 = source._repeatedSfixed64
+      _repeatedSint32 = source._repeatedSint32
+      _repeatedSint64 = source._repeatedSint64
+      _repeatedString = source._repeatedString
+      _repeatedUint32 = source._repeatedUint32
+      _repeatedUint64 = source._repeatedUint64
       _repeating = source._repeating
       _requestStreaming = source._requestStreaming
       _requestTypeURL = source._requestTypeURL
@@ -7526,6 +7971,24 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
       _setExtensionValue = source._setExtensionValue
       _shift = source._shift
       _simpleExtensionMap = source._simpleExtensionMap
+      _singularBool = source._singularBool
+      _singularBytes = source._singularBytes
+      _singularDouble = source._singularDouble
+      _singularEnum = source._singularEnum
+      _singularFixed32 = source._singularFixed32
+      _singularFixed64 = source._singularFixed64
+      _singularFloat = source._singularFloat
+      _singularGroup = source._singularGroup
+      _singularInt32 = source._singularInt32
+      _singularInt64 = source._singularInt64
+      _singularMessage = source._singularMessage
+      _singularSfixed32 = source._singularSfixed32
+      _singularSfixed64 = source._singularSfixed64
+      _singularSint32 = source._singularSint32
+      _singularSint64 = source._singularSint64
+      _singularString = source._singularString
+      _singularUint32 = source._singularUint32
+      _singularUint64 = source._singularUint64
       _size = source._size
       _sizer = source._sizer
       _source = source._source
@@ -7580,6 +8043,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
       _timeIntervalSince1970 = source._timeIntervalSince1970
       _timeIntervalSinceReferenceDate = source._timeIntervalSinceReferenceDate
       _timestamp = source._timestamp
+      _toConcrete = source._toConcrete
       _total = source._total
       _totalArrayDepth = source._totalArrayDepth
       _totalSize = source._totalSize
@@ -8003,3568 +8467,1768 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         case 275: try { try decoder.decodeSingularInt32Field(value: &_storage._enumValueOptions) }()
         case 276: try { try decoder.decodeSingularInt32Field(value: &_storage._equatable) }()
         case 277: try { try decoder.decodeSingularInt32Field(value: &_storage._error) }()
-        case 278: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByArrayLiteral) }()
-        case 279: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByDictionaryLiteral) }()
-        case 280: try { try decoder.decodeSingularInt32Field(value: &_storage._ext) }()
-        case 281: try { try decoder.decodeSingularInt32Field(value: &_storage._extDecoder) }()
-        case 282: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteral) }()
-        case 283: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteralType) }()
-        case 284: try { try decoder.decodeSingularInt32Field(value: &_storage._extendee) }()
-        case 285: try { try decoder.decodeSingularInt32Field(value: &_storage._extensibleMessage) }()
-        case 286: try { try decoder.decodeSingularInt32Field(value: &_storage._extension) }()
-        case 287: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionField) }()
-        case 288: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldNumber) }()
-        case 289: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldValueSet) }()
-        case 290: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionMap) }()
-        case 291: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionRange) }()
-        case 292: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionRangeOptions) }()
-        case 293: try { try decoder.decodeSingularInt32Field(value: &_storage._extensions) }()
-        case 294: try { try decoder.decodeSingularInt32Field(value: &_storage._extras) }()
-        case 295: try { try decoder.decodeSingularInt32Field(value: &_storage._f) }()
-        case 296: try { try decoder.decodeSingularInt32Field(value: &_storage._false) }()
-        case 297: try { try decoder.decodeSingularInt32Field(value: &_storage._features) }()
-        case 298: try { try decoder.decodeSingularInt32Field(value: &_storage._featureSet) }()
-        case 299: try { try decoder.decodeSingularInt32Field(value: &_storage._featureSetDefaults) }()
-        case 300: try { try decoder.decodeSingularInt32Field(value: &_storage._featureSetEditionDefault) }()
-        case 301: try { try decoder.decodeSingularInt32Field(value: &_storage._field) }()
-        case 302: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldData) }()
-        case 303: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldDescriptorProto) }()
-        case 304: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldMask) }()
-        case 305: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName) }()
-        case 306: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNameCount) }()
-        case 307: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNum) }()
-        case 308: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumber) }()
-        case 309: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumberForProto) }()
-        case 310: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldOptions) }()
-        case 311: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldPresence) }()
-        case 312: try { try decoder.decodeSingularInt32Field(value: &_storage._fields) }()
-        case 313: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldSize) }()
-        case 314: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldTag) }()
-        case 315: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldType) }()
-        case 316: try { try decoder.decodeSingularInt32Field(value: &_storage._file) }()
-        case 317: try { try decoder.decodeSingularInt32Field(value: &_storage._fileDescriptorProto) }()
-        case 318: try { try decoder.decodeSingularInt32Field(value: &_storage._fileDescriptorSet) }()
-        case 319: try { try decoder.decodeSingularInt32Field(value: &_storage._fileName) }()
-        case 320: try { try decoder.decodeSingularInt32Field(value: &_storage._fileOptions) }()
-        case 321: try { try decoder.decodeSingularInt32Field(value: &_storage._filter) }()
-        case 322: try { try decoder.decodeSingularInt32Field(value: &_storage._final) }()
-        case 323: try { try decoder.decodeSingularInt32Field(value: &_storage._first) }()
-        case 324: try { try decoder.decodeSingularInt32Field(value: &_storage._firstItem) }()
-        case 325: try { try decoder.decodeSingularInt32Field(value: &_storage._float) }()
-        case 326: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteral) }()
-        case 327: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteralType) }()
-        case 328: try { try decoder.decodeSingularInt32Field(value: &_storage._floatValue) }()
-        case 329: try { try decoder.decodeSingularInt32Field(value: &_storage._forMessageName) }()
-        case 330: try { try decoder.decodeSingularInt32Field(value: &_storage._formUnion) }()
-        case 331: try { try decoder.decodeSingularInt32Field(value: &_storage._forReadingFrom) }()
-        case 332: try { try decoder.decodeSingularInt32Field(value: &_storage._forTypeURL) }()
-        case 333: try { try decoder.decodeSingularInt32Field(value: &_storage._forwardParser) }()
-        case 334: try { try decoder.decodeSingularInt32Field(value: &_storage._forWritingInto) }()
-        case 335: try { try decoder.decodeSingularInt32Field(value: &_storage._from) }()
-        case 336: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii2) }()
-        case 337: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii4) }()
-        case 338: try { try decoder.decodeSingularInt32Field(value: &_storage._fromByteOffset) }()
-        case 339: try { try decoder.decodeSingularInt32Field(value: &_storage._fromHexDigit) }()
-        case 340: try { try decoder.decodeSingularInt32Field(value: &_storage._fullName) }()
-        case 341: try { try decoder.decodeSingularInt32Field(value: &_storage._func) }()
-        case 342: try { try decoder.decodeSingularInt32Field(value: &_storage._g) }()
-        case 343: try { try decoder.decodeSingularInt32Field(value: &_storage._generatedCodeInfo) }()
-        case 344: try { try decoder.decodeSingularInt32Field(value: &_storage._get) }()
-        case 345: try { try decoder.decodeSingularInt32Field(value: &_storage._getExtensionValue) }()
-        case 346: try { try decoder.decodeSingularInt32Field(value: &_storage._googleapis) }()
-        case 347: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufAny) }()
-        case 348: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufApi) }()
-        case 349: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBoolValue) }()
-        case 350: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBytesValue) }()
-        case 351: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDescriptorProto) }()
-        case 352: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDoubleValue) }()
-        case 353: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDuration) }()
-        case 354: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEdition) }()
-        case 355: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEmpty) }()
-        case 356: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnum) }()
-        case 357: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumDescriptorProto) }()
-        case 358: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumOptions) }()
-        case 359: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValue) }()
-        case 360: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueDescriptorProto) }()
-        case 361: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueOptions) }()
-        case 362: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufExtensionRangeOptions) }()
-        case 363: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFeatureSet) }()
-        case 364: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFeatureSetDefaults) }()
-        case 365: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufField) }()
-        case 366: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldDescriptorProto) }()
-        case 367: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldMask) }()
-        case 368: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldOptions) }()
-        case 369: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorProto) }()
-        case 370: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorSet) }()
-        case 371: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileOptions) }()
-        case 372: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFloatValue) }()
-        case 373: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufGeneratedCodeInfo) }()
-        case 374: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt32Value) }()
-        case 375: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt64Value) }()
-        case 376: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufListValue) }()
-        case 377: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMessageOptions) }()
-        case 378: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethod) }()
-        case 379: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodDescriptorProto) }()
-        case 380: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodOptions) }()
-        case 381: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMixin) }()
-        case 382: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufNullValue) }()
-        case 383: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofDescriptorProto) }()
-        case 384: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofOptions) }()
-        case 385: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOption) }()
-        case 386: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceDescriptorProto) }()
-        case 387: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceOptions) }()
-        case 388: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceCodeInfo) }()
-        case 389: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceContext) }()
-        case 390: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStringValue) }()
-        case 391: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStruct) }()
-        case 392: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSyntax) }()
-        case 393: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufTimestamp) }()
-        case 394: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufType) }()
-        case 395: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint32Value) }()
-        case 396: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint64Value) }()
-        case 397: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUninterpretedOption) }()
-        case 398: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufValue) }()
-        case 399: try { try decoder.decodeSingularInt32Field(value: &_storage._goPackage) }()
-        case 400: try { try decoder.decodeSingularInt32Field(value: &_storage._group) }()
-        case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._groupFieldNumberStack) }()
-        case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._groupSize) }()
-        case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._hadOneofValue) }()
-        case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._handleConflictingOneOf) }()
-        case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAggregateValue_p) }()
-        case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAllowAlias_p) }()
-        case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._hasBegin_p) }()
-        case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcEnableArenas_p) }()
-        case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcGenericServices_p) }()
-        case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._hasClientStreaming_p) }()
-        case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCsharpNamespace_p) }()
-        case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCtype_p) }()
-        case 413: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDebugRedact_p) }()
-        case 414: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDefaultValue_p) }()
-        case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecated_p) }()
-        case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecatedLegacyJsonFieldConflicts_p) }()
-        case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDoubleValue_p) }()
-        case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEdition_p) }()
-        case 419: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnd_p) }()
-        case 420: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnumType_p) }()
-        case 421: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtendee_p) }()
-        case 422: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtensionValue_p) }()
-        case 423: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFeatures_p) }()
-        case 424: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFieldPresence_p) }()
-        case 425: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFullName_p) }()
-        case 426: try { try decoder.decodeSingularInt32Field(value: &_storage._hasGoPackage_p) }()
-        case 427: try { try decoder.decodeSingularInt32Field(value: &_storage._hash) }()
-        case 428: try { try decoder.decodeSingularInt32Field(value: &_storage._hashable) }()
-        case 429: try { try decoder.decodeSingularInt32Field(value: &_storage._hasher) }()
-        case 430: try { try decoder.decodeSingularInt32Field(value: &_storage._hashVisitor) }()
-        case 431: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdempotencyLevel_p) }()
-        case 432: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdentifierValue_p) }()
-        case 433: try { try decoder.decodeSingularInt32Field(value: &_storage._hasInputType_p) }()
-        case 434: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIsExtension_p) }()
-        case 435: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenerateEqualsAndHash_p) }()
-        case 436: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenericServices_p) }()
-        case 437: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaMultipleFiles_p) }()
-        case 438: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaOuterClassname_p) }()
-        case 439: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaPackage_p) }()
-        case 440: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaStringCheckUtf8_p) }()
-        case 441: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJsonFormat_p) }()
-        case 442: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJsonName_p) }()
-        case 443: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJstype_p) }()
-        case 444: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLabel_p) }()
-        case 445: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLazy_p) }()
-        case 446: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLeadingComments_p) }()
-        case 447: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMapEntry_p) }()
-        case 448: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMaximumEdition_p) }()
-        case 449: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMessageEncoding_p) }()
-        case 450: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMessageSetWireFormat_p) }()
-        case 451: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMinimumEdition_p) }()
-        case 452: try { try decoder.decodeSingularInt32Field(value: &_storage._hasName_p) }()
-        case 453: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNamePart_p) }()
-        case 454: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNegativeIntValue_p) }()
-        case 455: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNoStandardDescriptorAccessor_p) }()
-        case 456: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNumber_p) }()
-        case 457: try { try decoder.decodeSingularInt32Field(value: &_storage._hasObjcClassPrefix_p) }()
-        case 458: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOneofIndex_p) }()
-        case 459: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptimizeFor_p) }()
-        case 460: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptions_p) }()
-        case 461: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOutputType_p) }()
-        case 462: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPackage_p) }()
-        case 463: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPacked_p) }()
-        case 464: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpClassPrefix_p) }()
-        case 465: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpGenericServices_p) }()
-        case 466: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpMetadataNamespace_p) }()
-        case 467: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpNamespace_p) }()
-        case 468: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPositiveIntValue_p) }()
-        case 469: try { try decoder.decodeSingularInt32Field(value: &_storage._hasProto3Optional_p) }()
-        case 470: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPyGenericServices_p) }()
-        case 471: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRepeated_p) }()
-        case 472: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRepeatedFieldEncoding_p) }()
-        case 473: try { try decoder.decodeSingularInt32Field(value: &_storage._hasReserved_p) }()
-        case 474: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRetention_p) }()
-        case 475: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRubyPackage_p) }()
-        case 476: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSemantic_p) }()
-        case 477: try { try decoder.decodeSingularInt32Field(value: &_storage._hasServerStreaming_p) }()
-        case 478: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceCodeInfo_p) }()
-        case 479: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceContext_p) }()
-        case 480: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceFile_p) }()
-        case 481: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStart_p) }()
-        case 482: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStringValue_p) }()
-        case 483: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSwiftPrefix_p) }()
-        case 484: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSyntax_p) }()
-        case 485: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTrailingComments_p) }()
-        case 486: try { try decoder.decodeSingularInt32Field(value: &_storage._hasType_p) }()
-        case 487: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTypeName_p) }()
-        case 488: try { try decoder.decodeSingularInt32Field(value: &_storage._hasUnverifiedLazy_p) }()
-        case 489: try { try decoder.decodeSingularInt32Field(value: &_storage._hasUtf8Validation_p) }()
-        case 490: try { try decoder.decodeSingularInt32Field(value: &_storage._hasValue_p) }()
-        case 491: try { try decoder.decodeSingularInt32Field(value: &_storage._hasVerification_p) }()
-        case 492: try { try decoder.decodeSingularInt32Field(value: &_storage._hasWeak_p) }()
-        case 493: try { try decoder.decodeSingularInt32Field(value: &_storage._hour) }()
-        case 494: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }()
-        case 495: try { try decoder.decodeSingularInt32Field(value: &_storage._idempotencyLevel) }()
-        case 496: try { try decoder.decodeSingularInt32Field(value: &_storage._identifierValue) }()
-        case 497: try { try decoder.decodeSingularInt32Field(value: &_storage._if) }()
-        case 498: try { try decoder.decodeSingularInt32Field(value: &_storage._ignoreUnknownFields) }()
-        case 499: try { try decoder.decodeSingularInt32Field(value: &_storage._index) }()
-        case 500: try { try decoder.decodeSingularInt32Field(value: &_storage._init_p) }()
-        case 501: try { try decoder.decodeSingularInt32Field(value: &_storage._inout) }()
-        case 502: try { try decoder.decodeSingularInt32Field(value: &_storage._inputType) }()
-        case 503: try { try decoder.decodeSingularInt32Field(value: &_storage._insert) }()
-        case 504: try { try decoder.decodeSingularInt32Field(value: &_storage._int) }()
-        case 505: try { try decoder.decodeSingularInt32Field(value: &_storage._int32) }()
-        case 506: try { try decoder.decodeSingularInt32Field(value: &_storage._int32Value) }()
-        case 507: try { try decoder.decodeSingularInt32Field(value: &_storage._int64) }()
-        case 508: try { try decoder.decodeSingularInt32Field(value: &_storage._int64Value) }()
-        case 509: try { try decoder.decodeSingularInt32Field(value: &_storage._int8) }()
-        case 510: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteral) }()
-        case 511: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteralType) }()
-        case 512: try { try decoder.decodeSingularInt32Field(value: &_storage._intern) }()
-        case 513: try { try decoder.decodeSingularInt32Field(value: &_storage._internal) }()
-        case 514: try { try decoder.decodeSingularInt32Field(value: &_storage._internalState) }()
-        case 515: try { try decoder.decodeSingularInt32Field(value: &_storage._into) }()
-        case 516: try { try decoder.decodeSingularInt32Field(value: &_storage._ints) }()
-        case 517: try { try decoder.decodeSingularInt32Field(value: &_storage._isA) }()
-        case 518: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqual) }()
-        case 519: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqualTo) }()
-        case 520: try { try decoder.decodeSingularInt32Field(value: &_storage._isExtension) }()
-        case 521: try { try decoder.decodeSingularInt32Field(value: &_storage._isInitialized_p) }()
-        case 522: try { try decoder.decodeSingularInt32Field(value: &_storage._isNegative) }()
-        case 523: try { try decoder.decodeSingularInt32Field(value: &_storage._itemTagsEncodedSize) }()
-        case 524: try { try decoder.decodeSingularInt32Field(value: &_storage._iterator) }()
-        case 525: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenerateEqualsAndHash) }()
-        case 526: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenericServices) }()
-        case 527: try { try decoder.decodeSingularInt32Field(value: &_storage._javaMultipleFiles) }()
-        case 528: try { try decoder.decodeSingularInt32Field(value: &_storage._javaOuterClassname) }()
-        case 529: try { try decoder.decodeSingularInt32Field(value: &_storage._javaPackage) }()
-        case 530: try { try decoder.decodeSingularInt32Field(value: &_storage._javaStringCheckUtf8) }()
-        case 531: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecoder) }()
-        case 532: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingError) }()
-        case 533: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingOptions) }()
-        case 534: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonEncoder) }()
-        case 535: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingError) }()
-        case 536: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingOptions) }()
-        case 537: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingVisitor) }()
-        case 538: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonFormat) }()
-        case 539: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonmapEncodingVisitor) }()
-        case 540: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonName) }()
-        case 541: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPath) }()
-        case 542: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPaths) }()
-        case 543: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonscanner) }()
-        case 544: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonString) }()
-        case 545: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonText) }()
-        case 546: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonUtf8Bytes) }()
-        case 547: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonUtf8Data) }()
-        case 548: try { try decoder.decodeSingularInt32Field(value: &_storage._jstype) }()
-        case 549: try { try decoder.decodeSingularInt32Field(value: &_storage._k) }()
-        case 550: try { try decoder.decodeSingularInt32Field(value: &_storage._kChunkSize) }()
-        case 551: try { try decoder.decodeSingularInt32Field(value: &_storage._key) }()
-        case 552: try { try decoder.decodeSingularInt32Field(value: &_storage._keyField) }()
-        case 553: try { try decoder.decodeSingularInt32Field(value: &_storage._keyFieldOpt) }()
-        case 554: try { try decoder.decodeSingularInt32Field(value: &_storage._keyType) }()
-        case 555: try { try decoder.decodeSingularInt32Field(value: &_storage._kind) }()
-        case 556: try { try decoder.decodeSingularInt32Field(value: &_storage._l) }()
-        case 557: try { try decoder.decodeSingularInt32Field(value: &_storage._label) }()
-        case 558: try { try decoder.decodeSingularInt32Field(value: &_storage._lazy) }()
-        case 559: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingComments) }()
-        case 560: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingDetachedComments) }()
-        case 561: try { try decoder.decodeSingularInt32Field(value: &_storage._length) }()
-        case 562: try { try decoder.decodeSingularInt32Field(value: &_storage._lessThan) }()
-        case 563: try { try decoder.decodeSingularInt32Field(value: &_storage._let) }()
-        case 564: try { try decoder.decodeSingularInt32Field(value: &_storage._lhs) }()
-        case 565: try { try decoder.decodeSingularInt32Field(value: &_storage._list) }()
-        case 566: try { try decoder.decodeSingularInt32Field(value: &_storage._listOfMessages) }()
-        case 567: try { try decoder.decodeSingularInt32Field(value: &_storage._listValue) }()
-        case 568: try { try decoder.decodeSingularInt32Field(value: &_storage._littleEndian) }()
-        case 569: try { try decoder.decodeSingularInt32Field(value: &_storage._littleEndianBytes) }()
-        case 570: try { try decoder.decodeSingularInt32Field(value: &_storage._load) }()
-        case 571: try { try decoder.decodeSingularInt32Field(value: &_storage._localHasher) }()
-        case 572: try { try decoder.decodeSingularInt32Field(value: &_storage._location) }()
-        case 573: try { try decoder.decodeSingularInt32Field(value: &_storage._m) }()
-        case 574: try { try decoder.decodeSingularInt32Field(value: &_storage._major) }()
-        case 575: try { try decoder.decodeSingularInt32Field(value: &_storage._makeAsyncIterator) }()
-        case 576: try { try decoder.decodeSingularInt32Field(value: &_storage._makeIterator) }()
-        case 577: try { try decoder.decodeSingularInt32Field(value: &_storage._mapEntry) }()
-        case 578: try { try decoder.decodeSingularInt32Field(value: &_storage._mapKeyType) }()
-        case 579: try { try decoder.decodeSingularInt32Field(value: &_storage._mapToMessages) }()
-        case 580: try { try decoder.decodeSingularInt32Field(value: &_storage._mapValueType) }()
-        case 581: try { try decoder.decodeSingularInt32Field(value: &_storage._mapVisitor) }()
-        case 582: try { try decoder.decodeSingularInt32Field(value: &_storage._maximumEdition) }()
-        case 583: try { try decoder.decodeSingularInt32Field(value: &_storage._mdayStart) }()
-        case 584: try { try decoder.decodeSingularInt32Field(value: &_storage._merge) }()
-        case 585: try { try decoder.decodeSingularInt32Field(value: &_storage._message) }()
-        case 586: try { try decoder.decodeSingularInt32Field(value: &_storage._messageDepthLimit) }()
-        case 587: try { try decoder.decodeSingularInt32Field(value: &_storage._messageEncoding) }()
-        case 588: try { try decoder.decodeSingularInt32Field(value: &_storage._messageExtension) }()
-        case 589: try { try decoder.decodeSingularInt32Field(value: &_storage._messageImplementationBase) }()
-        case 590: try { try decoder.decodeSingularInt32Field(value: &_storage._messageOptions) }()
-        case 591: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSet) }()
-        case 592: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSetWireFormat) }()
-        case 593: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSize) }()
-        case 594: try { try decoder.decodeSingularInt32Field(value: &_storage._messageType) }()
-        case 595: try { try decoder.decodeSingularInt32Field(value: &_storage._method) }()
-        case 596: try { try decoder.decodeSingularInt32Field(value: &_storage._methodDescriptorProto) }()
-        case 597: try { try decoder.decodeSingularInt32Field(value: &_storage._methodOptions) }()
-        case 598: try { try decoder.decodeSingularInt32Field(value: &_storage._methods) }()
-        case 599: try { try decoder.decodeSingularInt32Field(value: &_storage._min) }()
-        case 600: try { try decoder.decodeSingularInt32Field(value: &_storage._minimumEdition) }()
-        case 601: try { try decoder.decodeSingularInt32Field(value: &_storage._minor) }()
-        case 602: try { try decoder.decodeSingularInt32Field(value: &_storage._mixin) }()
-        case 603: try { try decoder.decodeSingularInt32Field(value: &_storage._mixins) }()
-        case 604: try { try decoder.decodeSingularInt32Field(value: &_storage._modifier) }()
-        case 605: try { try decoder.decodeSingularInt32Field(value: &_storage._modify) }()
-        case 606: try { try decoder.decodeSingularInt32Field(value: &_storage._month) }()
-        case 607: try { try decoder.decodeSingularInt32Field(value: &_storage._msgExtension) }()
-        case 608: try { try decoder.decodeSingularInt32Field(value: &_storage._mutating) }()
-        case 609: try { try decoder.decodeSingularInt32Field(value: &_storage._n) }()
-        case 610: try { try decoder.decodeSingularInt32Field(value: &_storage._name) }()
-        case 611: try { try decoder.decodeSingularInt32Field(value: &_storage._nameDescription) }()
-        case 612: try { try decoder.decodeSingularInt32Field(value: &_storage._nameMap) }()
-        case 613: try { try decoder.decodeSingularInt32Field(value: &_storage._namePart) }()
-        case 614: try { try decoder.decodeSingularInt32Field(value: &_storage._names) }()
-        case 615: try { try decoder.decodeSingularInt32Field(value: &_storage._nanos) }()
-        case 616: try { try decoder.decodeSingularInt32Field(value: &_storage._negativeIntValue) }()
-        case 617: try { try decoder.decodeSingularInt32Field(value: &_storage._nestedType) }()
-        case 618: try { try decoder.decodeSingularInt32Field(value: &_storage._newL) }()
-        case 619: try { try decoder.decodeSingularInt32Field(value: &_storage._newList) }()
-        case 620: try { try decoder.decodeSingularInt32Field(value: &_storage._newValue) }()
-        case 621: try { try decoder.decodeSingularInt32Field(value: &_storage._next) }()
-        case 622: try { try decoder.decodeSingularInt32Field(value: &_storage._nextByte) }()
-        case 623: try { try decoder.decodeSingularInt32Field(value: &_storage._nextFieldNumber) }()
-        case 624: try { try decoder.decodeSingularInt32Field(value: &_storage._nextVarInt) }()
-        case 625: try { try decoder.decodeSingularInt32Field(value: &_storage._nil) }()
-        case 626: try { try decoder.decodeSingularInt32Field(value: &_storage._nilLiteral) }()
-        case 627: try { try decoder.decodeSingularInt32Field(value: &_storage._noStandardDescriptorAccessor) }()
-        case 628: try { try decoder.decodeSingularInt32Field(value: &_storage._nullValue) }()
-        case 629: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }()
-        case 630: try { try decoder.decodeSingularInt32Field(value: &_storage._numberValue) }()
-        case 631: try { try decoder.decodeSingularInt32Field(value: &_storage._objcClassPrefix) }()
-        case 632: try { try decoder.decodeSingularInt32Field(value: &_storage._of) }()
-        case 633: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofDecl) }()
-        case 634: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofDescriptorProto) }()
-        case 635: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofIndex) }()
-        case 636: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofOptions) }()
-        case 637: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofs) }()
-        case 638: try { try decoder.decodeSingularInt32Field(value: &_storage._oneOfKind) }()
-        case 639: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeFor) }()
-        case 640: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeMode) }()
-        case 641: try { try decoder.decodeSingularInt32Field(value: &_storage._option) }()
-        case 642: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalEnumExtensionField) }()
-        case 643: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalExtensionField) }()
-        case 644: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalGroupExtensionField) }()
-        case 645: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalMessageExtensionField) }()
-        case 646: try { try decoder.decodeSingularInt32Field(value: &_storage._optionRetention) }()
-        case 647: try { try decoder.decodeSingularInt32Field(value: &_storage._options) }()
-        case 648: try { try decoder.decodeSingularInt32Field(value: &_storage._optionTargetType) }()
-        case 649: try { try decoder.decodeSingularInt32Field(value: &_storage._other) }()
-        case 650: try { try decoder.decodeSingularInt32Field(value: &_storage._others) }()
-        case 651: try { try decoder.decodeSingularInt32Field(value: &_storage._out) }()
-        case 652: try { try decoder.decodeSingularInt32Field(value: &_storage._outputType) }()
-        case 653: try { try decoder.decodeSingularInt32Field(value: &_storage._p) }()
-        case 654: try { try decoder.decodeSingularInt32Field(value: &_storage._package) }()
-        case 655: try { try decoder.decodeSingularInt32Field(value: &_storage._packed) }()
-        case 656: try { try decoder.decodeSingularInt32Field(value: &_storage._packedEnumExtensionField) }()
-        case 657: try { try decoder.decodeSingularInt32Field(value: &_storage._packedExtensionField) }()
-        case 658: try { try decoder.decodeSingularInt32Field(value: &_storage._padding) }()
-        case 659: try { try decoder.decodeSingularInt32Field(value: &_storage._parent) }()
-        case 660: try { try decoder.decodeSingularInt32Field(value: &_storage._parse) }()
-        case 661: try { try decoder.decodeSingularInt32Field(value: &_storage._path) }()
-        case 662: try { try decoder.decodeSingularInt32Field(value: &_storage._paths) }()
-        case 663: try { try decoder.decodeSingularInt32Field(value: &_storage._payload) }()
-        case 664: try { try decoder.decodeSingularInt32Field(value: &_storage._payloadSize) }()
-        case 665: try { try decoder.decodeSingularInt32Field(value: &_storage._phpClassPrefix) }()
-        case 666: try { try decoder.decodeSingularInt32Field(value: &_storage._phpGenericServices) }()
-        case 667: try { try decoder.decodeSingularInt32Field(value: &_storage._phpMetadataNamespace) }()
-        case 668: try { try decoder.decodeSingularInt32Field(value: &_storage._phpNamespace) }()
-        case 669: try { try decoder.decodeSingularInt32Field(value: &_storage._pos) }()
-        case 670: try { try decoder.decodeSingularInt32Field(value: &_storage._positiveIntValue) }()
-        case 671: try { try decoder.decodeSingularInt32Field(value: &_storage._prefix) }()
-        case 672: try { try decoder.decodeSingularInt32Field(value: &_storage._preserveProtoFieldNames) }()
-        case 673: try { try decoder.decodeSingularInt32Field(value: &_storage._preTraverse) }()
-        case 674: try { try decoder.decodeSingularInt32Field(value: &_storage._printUnknownFields) }()
-        case 675: try { try decoder.decodeSingularInt32Field(value: &_storage._proto2) }()
-        case 676: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3DefaultValue) }()
-        case 677: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3Optional) }()
-        case 678: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversionCheck) }()
-        case 679: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversion3) }()
-        case 680: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBool) }()
-        case 681: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBytes) }()
-        case 682: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufDouble) }()
-        case 683: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufEnumMap) }()
-        case 684: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtension) }()
-        case 685: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed32) }()
-        case 686: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed64) }()
-        case 687: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFloat) }()
-        case 688: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt32) }()
-        case 689: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt64) }()
-        case 690: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMap) }()
-        case 691: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMessageMap) }()
-        case 692: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed32) }()
-        case 693: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed64) }()
-        case 694: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint32) }()
-        case 695: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint64) }()
-        case 696: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufString) }()
-        case 697: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint32) }()
-        case 698: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint64) }()
-        case 699: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtensionFieldValues) }()
-        case 700: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFieldNumber) }()
-        case 701: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufGeneratedIsEqualTo) }()
-        case 702: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNameMap) }()
-        case 703: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNewField) }()
-        case 704: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufPackage) }()
-        case 705: try { try decoder.decodeSingularInt32Field(value: &_storage._protocol) }()
-        case 706: try { try decoder.decodeSingularInt32Field(value: &_storage._protoFieldName) }()
-        case 707: try { try decoder.decodeSingularInt32Field(value: &_storage._protoMessageName) }()
-        case 708: try { try decoder.decodeSingularInt32Field(value: &_storage._protoNameProviding) }()
-        case 709: try { try decoder.decodeSingularInt32Field(value: &_storage._protoPaths) }()
-        case 710: try { try decoder.decodeSingularInt32Field(value: &_storage._public) }()
-        case 711: try { try decoder.decodeSingularInt32Field(value: &_storage._publicDependency) }()
-        case 712: try { try decoder.decodeSingularInt32Field(value: &_storage._putBoolValue) }()
-        case 713: try { try decoder.decodeSingularInt32Field(value: &_storage._putBytesValue) }()
-        case 714: try { try decoder.decodeSingularInt32Field(value: &_storage._putDoubleValue) }()
-        case 715: try { try decoder.decodeSingularInt32Field(value: &_storage._putEnumValue) }()
-        case 716: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint32) }()
-        case 717: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint64) }()
-        case 718: try { try decoder.decodeSingularInt32Field(value: &_storage._putFloatValue) }()
-        case 719: try { try decoder.decodeSingularInt32Field(value: &_storage._putInt64) }()
-        case 720: try { try decoder.decodeSingularInt32Field(value: &_storage._putStringValue) }()
-        case 721: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64) }()
-        case 722: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64Hex) }()
-        case 723: try { try decoder.decodeSingularInt32Field(value: &_storage._putVarInt) }()
-        case 724: try { try decoder.decodeSingularInt32Field(value: &_storage._putZigZagVarInt) }()
-        case 725: try { try decoder.decodeSingularInt32Field(value: &_storage._pyGenericServices) }()
-        case 726: try { try decoder.decodeSingularInt32Field(value: &_storage._r) }()
-        case 727: try { try decoder.decodeSingularInt32Field(value: &_storage._rawChars) }()
-        case 728: try { try decoder.decodeSingularInt32Field(value: &_storage._rawRepresentable) }()
-        case 729: try { try decoder.decodeSingularInt32Field(value: &_storage._rawValue) }()
-        case 730: try { try decoder.decodeSingularInt32Field(value: &_storage._read4HexDigits) }()
-        case 731: try { try decoder.decodeSingularInt32Field(value: &_storage._readBytes) }()
-        case 732: try { try decoder.decodeSingularInt32Field(value: &_storage._register) }()
-        case 733: try { try decoder.decodeSingularInt32Field(value: &_storage._repeated) }()
-        case 734: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedEnumExtensionField) }()
-        case 735: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedExtensionField) }()
-        case 736: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedFieldEncoding) }()
-        case 737: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedGroupExtensionField) }()
-        case 738: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedMessageExtensionField) }()
-        case 739: try { try decoder.decodeSingularInt32Field(value: &_storage._repeating) }()
-        case 740: try { try decoder.decodeSingularInt32Field(value: &_storage._requestStreaming) }()
-        case 741: try { try decoder.decodeSingularInt32Field(value: &_storage._requestTypeURL) }()
-        case 742: try { try decoder.decodeSingularInt32Field(value: &_storage._requiredSize) }()
-        case 743: try { try decoder.decodeSingularInt32Field(value: &_storage._responseStreaming) }()
-        case 744: try { try decoder.decodeSingularInt32Field(value: &_storage._responseTypeURL) }()
-        case 745: try { try decoder.decodeSingularInt32Field(value: &_storage._result) }()
-        case 746: try { try decoder.decodeSingularInt32Field(value: &_storage._retention) }()
-        case 747: try { try decoder.decodeSingularInt32Field(value: &_storage._rethrows) }()
-        case 748: try { try decoder.decodeSingularInt32Field(value: &_storage._return) }()
-        case 749: try { try decoder.decodeSingularInt32Field(value: &_storage._returnType) }()
-        case 750: try { try decoder.decodeSingularInt32Field(value: &_storage._revision) }()
-        case 751: try { try decoder.decodeSingularInt32Field(value: &_storage._rhs) }()
-        case 752: try { try decoder.decodeSingularInt32Field(value: &_storage._root) }()
-        case 753: try { try decoder.decodeSingularInt32Field(value: &_storage._rubyPackage) }()
-        case 754: try { try decoder.decodeSingularInt32Field(value: &_storage._s) }()
-        case 755: try { try decoder.decodeSingularInt32Field(value: &_storage._sawBackslash) }()
-        case 756: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection4Characters) }()
-        case 757: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection5Characters) }()
-        case 758: try { try decoder.decodeSingularInt32Field(value: &_storage._scanner) }()
-        case 759: try { try decoder.decodeSingularInt32Field(value: &_storage._seconds) }()
-        case 760: try { try decoder.decodeSingularInt32Field(value: &_storage._self_p) }()
-        case 761: try { try decoder.decodeSingularInt32Field(value: &_storage._semantic) }()
-        case 762: try { try decoder.decodeSingularInt32Field(value: &_storage._sendable) }()
-        case 763: try { try decoder.decodeSingularInt32Field(value: &_storage._separator) }()
-        case 764: try { try decoder.decodeSingularInt32Field(value: &_storage._serialize) }()
-        case 765: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedBytes) }()
-        case 766: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedData) }()
-        case 767: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedSize) }()
-        case 768: try { try decoder.decodeSingularInt32Field(value: &_storage._serverStreaming) }()
-        case 769: try { try decoder.decodeSingularInt32Field(value: &_storage._service) }()
-        case 770: try { try decoder.decodeSingularInt32Field(value: &_storage._serviceDescriptorProto) }()
-        case 771: try { try decoder.decodeSingularInt32Field(value: &_storage._serviceOptions) }()
-        case 772: try { try decoder.decodeSingularInt32Field(value: &_storage._set) }()
-        case 773: try { try decoder.decodeSingularInt32Field(value: &_storage._setExtensionValue) }()
-        case 774: try { try decoder.decodeSingularInt32Field(value: &_storage._shift) }()
-        case 775: try { try decoder.decodeSingularInt32Field(value: &_storage._simpleExtensionMap) }()
-        case 776: try { try decoder.decodeSingularInt32Field(value: &_storage._size) }()
-        case 777: try { try decoder.decodeSingularInt32Field(value: &_storage._sizer) }()
-        case 778: try { try decoder.decodeSingularInt32Field(value: &_storage._source) }()
-        case 779: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceCodeInfo) }()
-        case 780: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceContext) }()
-        case 781: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceEncoding) }()
-        case 782: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceFile) }()
-        case 783: try { try decoder.decodeSingularInt32Field(value: &_storage._span) }()
-        case 784: try { try decoder.decodeSingularInt32Field(value: &_storage._split) }()
-        case 785: try { try decoder.decodeSingularInt32Field(value: &_storage._start) }()
-        case 786: try { try decoder.decodeSingularInt32Field(value: &_storage._startArray) }()
-        case 787: try { try decoder.decodeSingularInt32Field(value: &_storage._startArrayObject) }()
-        case 788: try { try decoder.decodeSingularInt32Field(value: &_storage._startField) }()
-        case 789: try { try decoder.decodeSingularInt32Field(value: &_storage._startIndex) }()
-        case 790: try { try decoder.decodeSingularInt32Field(value: &_storage._startMessageField) }()
-        case 791: try { try decoder.decodeSingularInt32Field(value: &_storage._startObject) }()
-        case 792: try { try decoder.decodeSingularInt32Field(value: &_storage._startRegularField) }()
-        case 793: try { try decoder.decodeSingularInt32Field(value: &_storage._state) }()
-        case 794: try { try decoder.decodeSingularInt32Field(value: &_storage._static) }()
-        case 795: try { try decoder.decodeSingularInt32Field(value: &_storage._staticString) }()
-        case 796: try { try decoder.decodeSingularInt32Field(value: &_storage._storage) }()
-        case 797: try { try decoder.decodeSingularInt32Field(value: &_storage._string) }()
-        case 798: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteral) }()
-        case 799: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteralType) }()
-        case 800: try { try decoder.decodeSingularInt32Field(value: &_storage._stringResult) }()
-        case 801: try { try decoder.decodeSingularInt32Field(value: &_storage._stringValue) }()
-        case 802: try { try decoder.decodeSingularInt32Field(value: &_storage._struct) }()
-        case 803: try { try decoder.decodeSingularInt32Field(value: &_storage._structValue) }()
-        case 804: try { try decoder.decodeSingularInt32Field(value: &_storage._subDecoder) }()
-        case 805: try { try decoder.decodeSingularInt32Field(value: &_storage._subscript) }()
-        case 806: try { try decoder.decodeSingularInt32Field(value: &_storage._subVisitor) }()
-        case 807: try { try decoder.decodeSingularInt32Field(value: &_storage._swift) }()
-        case 808: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftPrefix) }()
-        case 809: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftProtobufContiguousBytes) }()
-        case 810: try { try decoder.decodeSingularInt32Field(value: &_storage._syntax) }()
-        case 811: try { try decoder.decodeSingularInt32Field(value: &_storage._t) }()
-        case 812: try { try decoder.decodeSingularInt32Field(value: &_storage._tag) }()
-        case 813: try { try decoder.decodeSingularInt32Field(value: &_storage._targets) }()
-        case 814: try { try decoder.decodeSingularInt32Field(value: &_storage._terminator) }()
-        case 815: try { try decoder.decodeSingularInt32Field(value: &_storage._testDecoder) }()
-        case 816: try { try decoder.decodeSingularInt32Field(value: &_storage._text) }()
-        case 817: try { try decoder.decodeSingularInt32Field(value: &_storage._textDecoder) }()
-        case 818: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecoder) }()
-        case 819: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingError) }()
-        case 820: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingOptions) }()
-        case 821: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingOptions) }()
-        case 822: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingVisitor) }()
-        case 823: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatString) }()
-        case 824: try { try decoder.decodeSingularInt32Field(value: &_storage._throwOrIgnore) }()
-        case 825: try { try decoder.decodeSingularInt32Field(value: &_storage._throws) }()
-        case 826: try { try decoder.decodeSingularInt32Field(value: &_storage._timeInterval) }()
-        case 827: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSince1970) }()
-        case 828: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSinceReferenceDate) }()
-        case 829: try { try decoder.decodeSingularInt32Field(value: &_storage._timestamp) }()
-        case 830: try { try decoder.decodeSingularInt32Field(value: &_storage._total) }()
-        case 831: try { try decoder.decodeSingularInt32Field(value: &_storage._totalArrayDepth) }()
-        case 832: try { try decoder.decodeSingularInt32Field(value: &_storage._totalSize) }()
-        case 833: try { try decoder.decodeSingularInt32Field(value: &_storage._trailingComments) }()
-        case 834: try { try decoder.decodeSingularInt32Field(value: &_storage._traverse) }()
-        case 835: try { try decoder.decodeSingularInt32Field(value: &_storage._true) }()
-        case 836: try { try decoder.decodeSingularInt32Field(value: &_storage._try) }()
-        case 837: try { try decoder.decodeSingularInt32Field(value: &_storage._type) }()
-        case 838: try { try decoder.decodeSingularInt32Field(value: &_storage._typealias) }()
-        case 839: try { try decoder.decodeSingularInt32Field(value: &_storage._typeEnum) }()
-        case 840: try { try decoder.decodeSingularInt32Field(value: &_storage._typeName) }()
-        case 841: try { try decoder.decodeSingularInt32Field(value: &_storage._typePrefix) }()
-        case 842: try { try decoder.decodeSingularInt32Field(value: &_storage._typeStart) }()
-        case 843: try { try decoder.decodeSingularInt32Field(value: &_storage._typeUnknown) }()
-        case 844: try { try decoder.decodeSingularInt32Field(value: &_storage._typeURL) }()
-        case 845: try { try decoder.decodeSingularInt32Field(value: &_storage._uint32) }()
-        case 846: try { try decoder.decodeSingularInt32Field(value: &_storage._uint32Value) }()
-        case 847: try { try decoder.decodeSingularInt32Field(value: &_storage._uint64) }()
-        case 848: try { try decoder.decodeSingularInt32Field(value: &_storage._uint64Value) }()
-        case 849: try { try decoder.decodeSingularInt32Field(value: &_storage._uint8) }()
-        case 850: try { try decoder.decodeSingularInt32Field(value: &_storage._unchecked) }()
-        case 851: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteral) }()
-        case 852: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteralType) }()
-        case 853: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalars) }()
-        case 854: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarView) }()
-        case 855: try { try decoder.decodeSingularInt32Field(value: &_storage._uninterpretedOption) }()
-        case 856: try { try decoder.decodeSingularInt32Field(value: &_storage._union) }()
-        case 857: try { try decoder.decodeSingularInt32Field(value: &_storage._uniqueStorage) }()
-        case 858: try { try decoder.decodeSingularInt32Field(value: &_storage._unknown) }()
-        case 859: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownFields_p) }()
-        case 860: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownStorage) }()
-        case 861: try { try decoder.decodeSingularInt32Field(value: &_storage._unpackTo) }()
-        case 862: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeBufferPointer) }()
-        case 863: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutablePointer) }()
-        case 864: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutableRawBufferPointer) }()
-        case 865: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawBufferPointer) }()
-        case 866: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawPointer) }()
-        case 867: try { try decoder.decodeSingularInt32Field(value: &_storage._unverifiedLazy) }()
-        case 868: try { try decoder.decodeSingularInt32Field(value: &_storage._updatedOptions) }()
-        case 869: try { try decoder.decodeSingularInt32Field(value: &_storage._url) }()
-        case 870: try { try decoder.decodeSingularInt32Field(value: &_storage._useDeterministicOrdering) }()
-        case 871: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8) }()
-        case 872: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8Ptr) }()
-        case 873: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8ToDouble) }()
-        case 874: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8Validation) }()
-        case 875: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8View) }()
-        case 876: try { try decoder.decodeSingularInt32Field(value: &_storage._v) }()
-        case 877: try { try decoder.decodeSingularInt32Field(value: &_storage._value) }()
-        case 878: try { try decoder.decodeSingularInt32Field(value: &_storage._valueField) }()
-        case 879: try { try decoder.decodeSingularInt32Field(value: &_storage._values) }()
-        case 880: try { try decoder.decodeSingularInt32Field(value: &_storage._valueType) }()
-        case 881: try { try decoder.decodeSingularInt32Field(value: &_storage._var) }()
-        case 882: try { try decoder.decodeSingularInt32Field(value: &_storage._verification) }()
-        case 883: try { try decoder.decodeSingularInt32Field(value: &_storage._verificationState) }()
-        case 884: try { try decoder.decodeSingularInt32Field(value: &_storage._version) }()
-        case 885: try { try decoder.decodeSingularInt32Field(value: &_storage._versionString) }()
-        case 886: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFields) }()
-        case 887: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFieldsAsMessageSet) }()
-        case 888: try { try decoder.decodeSingularInt32Field(value: &_storage._visitMapField) }()
-        case 889: try { try decoder.decodeSingularInt32Field(value: &_storage._visitor) }()
-        case 890: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPacked) }()
-        case 891: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedBoolField) }()
-        case 892: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedDoubleField) }()
-        case 893: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedEnumField) }()
-        case 894: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed32Field) }()
-        case 895: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed64Field) }()
-        case 896: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFloatField) }()
-        case 897: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt32Field) }()
-        case 898: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt64Field) }()
-        case 899: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed32Field) }()
-        case 900: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed64Field) }()
-        case 901: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint32Field) }()
-        case 902: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint64Field) }()
-        case 903: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint32Field) }()
-        case 904: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint64Field) }()
-        case 905: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeated) }()
-        case 906: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBoolField) }()
-        case 907: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBytesField) }()
-        case 908: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedDoubleField) }()
-        case 909: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedEnumField) }()
-        case 910: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed32Field) }()
-        case 911: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed64Field) }()
-        case 912: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFloatField) }()
-        case 913: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedGroupField) }()
-        case 914: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt32Field) }()
-        case 915: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt64Field) }()
-        case 916: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedMessageField) }()
-        case 917: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed32Field) }()
-        case 918: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed64Field) }()
-        case 919: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint32Field) }()
-        case 920: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint64Field) }()
-        case 921: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedStringField) }()
-        case 922: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint32Field) }()
-        case 923: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint64Field) }()
-        case 924: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingular) }()
-        case 925: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBoolField) }()
-        case 926: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBytesField) }()
-        case 927: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularDoubleField) }()
-        case 928: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularEnumField) }()
-        case 929: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed32Field) }()
-        case 930: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed64Field) }()
-        case 931: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFloatField) }()
-        case 932: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularGroupField) }()
-        case 933: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt32Field) }()
-        case 934: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt64Field) }()
-        case 935: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularMessageField) }()
-        case 936: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed32Field) }()
-        case 937: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed64Field) }()
-        case 938: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint32Field) }()
-        case 939: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint64Field) }()
-        case 940: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularStringField) }()
-        case 941: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint32Field) }()
-        case 942: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint64Field) }()
-        case 943: try { try decoder.decodeSingularInt32Field(value: &_storage._visitUnknown) }()
-        case 944: try { try decoder.decodeSingularInt32Field(value: &_storage._wasDecoded) }()
-        case 945: try { try decoder.decodeSingularInt32Field(value: &_storage._weak) }()
-        case 946: try { try decoder.decodeSingularInt32Field(value: &_storage._weakDependency) }()
-        case 947: try { try decoder.decodeSingularInt32Field(value: &_storage._where) }()
-        case 948: try { try decoder.decodeSingularInt32Field(value: &_storage._wireFormat) }()
-        case 949: try { try decoder.decodeSingularInt32Field(value: &_storage._with) }()
-        case 950: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeBytes) }()
-        case 951: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeMutableBytes) }()
-        case 952: try { try decoder.decodeSingularInt32Field(value: &_storage._work) }()
-        case 953: try { try decoder.decodeSingularInt32Field(value: &_storage._wrapped) }()
-        case 954: try { try decoder.decodeSingularInt32Field(value: &_storage._wrappedType) }()
-        case 955: try { try decoder.decodeSingularInt32Field(value: &_storage._wrappedValue) }()
-        case 956: try { try decoder.decodeSingularInt32Field(value: &_storage._written) }()
-        case 957: try { try decoder.decodeSingularInt32Field(value: &_storage._yday) }()
+        case 278: try { try decoder.decodeSingularInt32Field(value: &_storage._escaping) }()
+        case 279: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByArrayLiteral) }()
+        case 280: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByDictionaryLiteral) }()
+        case 281: try { try decoder.decodeSingularInt32Field(value: &_storage._ext) }()
+        case 282: try { try decoder.decodeSingularInt32Field(value: &_storage._extDecoder) }()
+        case 283: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteral) }()
+        case 284: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteralType) }()
+        case 285: try { try decoder.decodeSingularInt32Field(value: &_storage._extendee) }()
+        case 286: try { try decoder.decodeSingularInt32Field(value: &_storage._extensibleMessage) }()
+        case 287: try { try decoder.decodeSingularInt32Field(value: &_storage._extension) }()
+        case 288: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionField) }()
+        case 289: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldNumber) }()
+        case 290: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFields) }()
+        case 291: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldsAsMessageSet) }()
+        case 292: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldValueSet) }()
+        case 293: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionMap) }()
+        case 294: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionRange) }()
+        case 295: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionRangeOptions) }()
+        case 296: try { try decoder.decodeSingularInt32Field(value: &_storage._extensions) }()
+        case 297: try { try decoder.decodeSingularInt32Field(value: &_storage._extras) }()
+        case 298: try { try decoder.decodeSingularInt32Field(value: &_storage._f) }()
+        case 299: try { try decoder.decodeSingularInt32Field(value: &_storage._false) }()
+        case 300: try { try decoder.decodeSingularInt32Field(value: &_storage._features) }()
+        case 301: try { try decoder.decodeSingularInt32Field(value: &_storage._featureSet) }()
+        case 302: try { try decoder.decodeSingularInt32Field(value: &_storage._featureSetDefaults) }()
+        case 303: try { try decoder.decodeSingularInt32Field(value: &_storage._featureSetEditionDefault) }()
+        case 304: try { try decoder.decodeSingularInt32Field(value: &_storage._field) }()
+        case 305: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldData) }()
+        case 306: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldDescriptorProto) }()
+        case 307: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldMask) }()
+        case 308: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName) }()
+        case 309: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNameCount) }()
+        case 310: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNum) }()
+        case 311: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumber) }()
+        case 312: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumberForProto) }()
+        case 313: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldOptions) }()
+        case 314: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldPresence) }()
+        case 315: try { try decoder.decodeSingularInt32Field(value: &_storage._fields) }()
+        case 316: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldSize) }()
+        case 317: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldTag) }()
+        case 318: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldType) }()
+        case 319: try { try decoder.decodeSingularInt32Field(value: &_storage._file) }()
+        case 320: try { try decoder.decodeSingularInt32Field(value: &_storage._fileDescriptorProto) }()
+        case 321: try { try decoder.decodeSingularInt32Field(value: &_storage._fileDescriptorSet) }()
+        case 322: try { try decoder.decodeSingularInt32Field(value: &_storage._fileName) }()
+        case 323: try { try decoder.decodeSingularInt32Field(value: &_storage._fileOptions) }()
+        case 324: try { try decoder.decodeSingularInt32Field(value: &_storage._filter) }()
+        case 325: try { try decoder.decodeSingularInt32Field(value: &_storage._final) }()
+        case 326: try { try decoder.decodeSingularInt32Field(value: &_storage._first) }()
+        case 327: try { try decoder.decodeSingularInt32Field(value: &_storage._firstItem) }()
+        case 328: try { try decoder.decodeSingularInt32Field(value: &_storage._float) }()
+        case 329: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteral) }()
+        case 330: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteralType) }()
+        case 331: try { try decoder.decodeSingularInt32Field(value: &_storage._floatValue) }()
+        case 332: try { try decoder.decodeSingularInt32Field(value: &_storage._forMessageName) }()
+        case 333: try { try decoder.decodeSingularInt32Field(value: &_storage._formUnion) }()
+        case 334: try { try decoder.decodeSingularInt32Field(value: &_storage._forReadingFrom) }()
+        case 335: try { try decoder.decodeSingularInt32Field(value: &_storage._forTypeURL) }()
+        case 336: try { try decoder.decodeSingularInt32Field(value: &_storage._forwardParser) }()
+        case 337: try { try decoder.decodeSingularInt32Field(value: &_storage._forWritingInto) }()
+        case 338: try { try decoder.decodeSingularInt32Field(value: &_storage._from) }()
+        case 339: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii2) }()
+        case 340: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii4) }()
+        case 341: try { try decoder.decodeSingularInt32Field(value: &_storage._fromByteOffset) }()
+        case 342: try { try decoder.decodeSingularInt32Field(value: &_storage._fromHexDigit) }()
+        case 343: try { try decoder.decodeSingularInt32Field(value: &_storage._fullName) }()
+        case 344: try { try decoder.decodeSingularInt32Field(value: &_storage._func) }()
+        case 345: try { try decoder.decodeSingularInt32Field(value: &_storage._g) }()
+        case 346: try { try decoder.decodeSingularInt32Field(value: &_storage._generatedCodeInfo) }()
+        case 347: try { try decoder.decodeSingularInt32Field(value: &_storage._get) }()
+        case 348: try { try decoder.decodeSingularInt32Field(value: &_storage._getExtensionValue) }()
+        case 349: try { try decoder.decodeSingularInt32Field(value: &_storage._getValue) }()
+        case 350: try { try decoder.decodeSingularInt32Field(value: &_storage._googleapis) }()
+        case 351: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufAny) }()
+        case 352: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufApi) }()
+        case 353: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBoolValue) }()
+        case 354: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBytesValue) }()
+        case 355: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDescriptorProto) }()
+        case 356: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDoubleValue) }()
+        case 357: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDuration) }()
+        case 358: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEdition) }()
+        case 359: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEmpty) }()
+        case 360: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnum) }()
+        case 361: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumDescriptorProto) }()
+        case 362: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumOptions) }()
+        case 363: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValue) }()
+        case 364: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueDescriptorProto) }()
+        case 365: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueOptions) }()
+        case 366: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufExtensionRangeOptions) }()
+        case 367: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFeatureSet) }()
+        case 368: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFeatureSetDefaults) }()
+        case 369: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufField) }()
+        case 370: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldDescriptorProto) }()
+        case 371: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldMask) }()
+        case 372: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldOptions) }()
+        case 373: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorProto) }()
+        case 374: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorSet) }()
+        case 375: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileOptions) }()
+        case 376: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFloatValue) }()
+        case 377: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufGeneratedCodeInfo) }()
+        case 378: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt32Value) }()
+        case 379: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt64Value) }()
+        case 380: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufListValue) }()
+        case 381: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMessageOptions) }()
+        case 382: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethod) }()
+        case 383: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodDescriptorProto) }()
+        case 384: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodOptions) }()
+        case 385: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMixin) }()
+        case 386: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufNullValue) }()
+        case 387: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofDescriptorProto) }()
+        case 388: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofOptions) }()
+        case 389: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOption) }()
+        case 390: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceDescriptorProto) }()
+        case 391: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceOptions) }()
+        case 392: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceCodeInfo) }()
+        case 393: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceContext) }()
+        case 394: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStringValue) }()
+        case 395: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStruct) }()
+        case 396: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSyntax) }()
+        case 397: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufTimestamp) }()
+        case 398: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufType) }()
+        case 399: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint32Value) }()
+        case 400: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint64Value) }()
+        case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUninterpretedOption) }()
+        case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufValue) }()
+        case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._goPackage) }()
+        case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._group) }()
+        case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._groupFieldNumberStack) }()
+        case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._groupSize) }()
+        case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._hadOneofValue) }()
+        case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._handleConflictingOneOf) }()
+        case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAggregateValue_p) }()
+        case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAllowAlias_p) }()
+        case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._hasBegin_p) }()
+        case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcEnableArenas_p) }()
+        case 413: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcGenericServices_p) }()
+        case 414: try { try decoder.decodeSingularInt32Field(value: &_storage._hasClientStreaming_p) }()
+        case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCsharpNamespace_p) }()
+        case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCtype_p) }()
+        case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDebugRedact_p) }()
+        case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDefaultValue_p) }()
+        case 419: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecated_p) }()
+        case 420: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecatedLegacyJsonFieldConflicts_p) }()
+        case 421: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDoubleValue_p) }()
+        case 422: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEdition_p) }()
+        case 423: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnd_p) }()
+        case 424: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnumType_p) }()
+        case 425: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtendee_p) }()
+        case 426: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtensionValue_p) }()
+        case 427: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFeatures_p) }()
+        case 428: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFieldPresence_p) }()
+        case 429: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFullName_p) }()
+        case 430: try { try decoder.decodeSingularInt32Field(value: &_storage._hasGoPackage_p) }()
+        case 431: try { try decoder.decodeSingularInt32Field(value: &_storage._hash) }()
+        case 432: try { try decoder.decodeSingularInt32Field(value: &_storage._hashable) }()
+        case 433: try { try decoder.decodeSingularInt32Field(value: &_storage._hasher) }()
+        case 434: try { try decoder.decodeSingularInt32Field(value: &_storage._hashVisitor) }()
+        case 435: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdempotencyLevel_p) }()
+        case 436: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdentifierValue_p) }()
+        case 437: try { try decoder.decodeSingularInt32Field(value: &_storage._hasInputType_p) }()
+        case 438: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIsExtension_p) }()
+        case 439: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenerateEqualsAndHash_p) }()
+        case 440: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenericServices_p) }()
+        case 441: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaMultipleFiles_p) }()
+        case 442: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaOuterClassname_p) }()
+        case 443: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaPackage_p) }()
+        case 444: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaStringCheckUtf8_p) }()
+        case 445: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJsonFormat_p) }()
+        case 446: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJsonName_p) }()
+        case 447: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJstype_p) }()
+        case 448: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLabel_p) }()
+        case 449: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLazy_p) }()
+        case 450: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLeadingComments_p) }()
+        case 451: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMapEntry_p) }()
+        case 452: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMaximumEdition_p) }()
+        case 453: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMessageEncoding_p) }()
+        case 454: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMessageSetWireFormat_p) }()
+        case 455: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMinimumEdition_p) }()
+        case 456: try { try decoder.decodeSingularInt32Field(value: &_storage._hasName_p) }()
+        case 457: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNamePart_p) }()
+        case 458: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNegativeIntValue_p) }()
+        case 459: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNoStandardDescriptorAccessor_p) }()
+        case 460: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNumber_p) }()
+        case 461: try { try decoder.decodeSingularInt32Field(value: &_storage._hasObjcClassPrefix_p) }()
+        case 462: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOneofIndex_p) }()
+        case 463: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptimizeFor_p) }()
+        case 464: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptions_p) }()
+        case 465: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOutputType_p) }()
+        case 466: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPackage_p) }()
+        case 467: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPacked_p) }()
+        case 468: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpClassPrefix_p) }()
+        case 469: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpGenericServices_p) }()
+        case 470: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpMetadataNamespace_p) }()
+        case 471: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpNamespace_p) }()
+        case 472: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPositiveIntValue_p) }()
+        case 473: try { try decoder.decodeSingularInt32Field(value: &_storage._hasProto3Optional_p) }()
+        case 474: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPyGenericServices_p) }()
+        case 475: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRepeated_p) }()
+        case 476: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRepeatedFieldEncoding_p) }()
+        case 477: try { try decoder.decodeSingularInt32Field(value: &_storage._hasReserved_p) }()
+        case 478: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRetention_p) }()
+        case 479: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRubyPackage_p) }()
+        case 480: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSemantic_p) }()
+        case 481: try { try decoder.decodeSingularInt32Field(value: &_storage._hasServerStreaming_p) }()
+        case 482: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceCodeInfo_p) }()
+        case 483: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceContext_p) }()
+        case 484: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceFile_p) }()
+        case 485: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStart_p) }()
+        case 486: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStringValue_p) }()
+        case 487: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSwiftPrefix_p) }()
+        case 488: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSyntax_p) }()
+        case 489: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTrailingComments_p) }()
+        case 490: try { try decoder.decodeSingularInt32Field(value: &_storage._hasType_p) }()
+        case 491: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTypeName_p) }()
+        case 492: try { try decoder.decodeSingularInt32Field(value: &_storage._hasUnverifiedLazy_p) }()
+        case 493: try { try decoder.decodeSingularInt32Field(value: &_storage._hasUtf8Validation_p) }()
+        case 494: try { try decoder.decodeSingularInt32Field(value: &_storage._hasValue_p) }()
+        case 495: try { try decoder.decodeSingularInt32Field(value: &_storage._hasVerification_p) }()
+        case 496: try { try decoder.decodeSingularInt32Field(value: &_storage._hasWeak_p) }()
+        case 497: try { try decoder.decodeSingularInt32Field(value: &_storage._hour) }()
+        case 498: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }()
+        case 499: try { try decoder.decodeSingularInt32Field(value: &_storage._idempotencyLevel) }()
+        case 500: try { try decoder.decodeSingularInt32Field(value: &_storage._identifierValue) }()
+        case 501: try { try decoder.decodeSingularInt32Field(value: &_storage._if) }()
+        case 502: try { try decoder.decodeSingularInt32Field(value: &_storage._ignoreUnknownFields) }()
+        case 503: try { try decoder.decodeSingularInt32Field(value: &_storage._index) }()
+        case 504: try { try decoder.decodeSingularInt32Field(value: &_storage._init_p) }()
+        case 505: try { try decoder.decodeSingularInt32Field(value: &_storage._inout) }()
+        case 506: try { try decoder.decodeSingularInt32Field(value: &_storage._inputType) }()
+        case 507: try { try decoder.decodeSingularInt32Field(value: &_storage._insert) }()
+        case 508: try { try decoder.decodeSingularInt32Field(value: &_storage._int) }()
+        case 509: try { try decoder.decodeSingularInt32Field(value: &_storage._int32) }()
+        case 510: try { try decoder.decodeSingularInt32Field(value: &_storage._int32Value) }()
+        case 511: try { try decoder.decodeSingularInt32Field(value: &_storage._int64) }()
+        case 512: try { try decoder.decodeSingularInt32Field(value: &_storage._int64Value) }()
+        case 513: try { try decoder.decodeSingularInt32Field(value: &_storage._int8) }()
+        case 514: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteral) }()
+        case 515: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteralType) }()
+        case 516: try { try decoder.decodeSingularInt32Field(value: &_storage._intern) }()
+        case 517: try { try decoder.decodeSingularInt32Field(value: &_storage._internal) }()
+        case 518: try { try decoder.decodeSingularInt32Field(value: &_storage._internalState) }()
+        case 519: try { try decoder.decodeSingularInt32Field(value: &_storage._into) }()
+        case 520: try { try decoder.decodeSingularInt32Field(value: &_storage._ints) }()
+        case 521: try { try decoder.decodeSingularInt32Field(value: &_storage._isA) }()
+        case 522: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqual) }()
+        case 523: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqualTo) }()
+        case 524: try { try decoder.decodeSingularInt32Field(value: &_storage._isExtension) }()
+        case 525: try { try decoder.decodeSingularInt32Field(value: &_storage._isInitialized_p) }()
+        case 526: try { try decoder.decodeSingularInt32Field(value: &_storage._isNegative) }()
+        case 527: try { try decoder.decodeSingularInt32Field(value: &_storage._isUnset) }()
+        case 528: try { try decoder.decodeSingularInt32Field(value: &_storage._itemTagsEncodedSize) }()
+        case 529: try { try decoder.decodeSingularInt32Field(value: &_storage._iterator) }()
+        case 530: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenerateEqualsAndHash) }()
+        case 531: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenericServices) }()
+        case 532: try { try decoder.decodeSingularInt32Field(value: &_storage._javaMultipleFiles) }()
+        case 533: try { try decoder.decodeSingularInt32Field(value: &_storage._javaOuterClassname) }()
+        case 534: try { try decoder.decodeSingularInt32Field(value: &_storage._javaPackage) }()
+        case 535: try { try decoder.decodeSingularInt32Field(value: &_storage._javaStringCheckUtf8) }()
+        case 536: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecoder) }()
+        case 537: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingError) }()
+        case 538: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingOptions) }()
+        case 539: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonEncoder) }()
+        case 540: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingError) }()
+        case 541: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingOptions) }()
+        case 542: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingVisitor) }()
+        case 543: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonFormat) }()
+        case 544: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonmapEncodingVisitor) }()
+        case 545: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonName) }()
+        case 546: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPath) }()
+        case 547: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPaths) }()
+        case 548: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonscanner) }()
+        case 549: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonString) }()
+        case 550: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonText) }()
+        case 551: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonUtf8Bytes) }()
+        case 552: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonUtf8Data) }()
+        case 553: try { try decoder.decodeSingularInt32Field(value: &_storage._jstype) }()
+        case 554: try { try decoder.decodeSingularInt32Field(value: &_storage._k) }()
+        case 555: try { try decoder.decodeSingularInt32Field(value: &_storage._kChunkSize) }()
+        case 556: try { try decoder.decodeSingularInt32Field(value: &_storage._key) }()
+        case 557: try { try decoder.decodeSingularInt32Field(value: &_storage._keyField) }()
+        case 558: try { try decoder.decodeSingularInt32Field(value: &_storage._keyFieldOpt) }()
+        case 559: try { try decoder.decodeSingularInt32Field(value: &_storage._keyType) }()
+        case 560: try { try decoder.decodeSingularInt32Field(value: &_storage._kind) }()
+        case 561: try { try decoder.decodeSingularInt32Field(value: &_storage._l) }()
+        case 562: try { try decoder.decodeSingularInt32Field(value: &_storage._label) }()
+        case 563: try { try decoder.decodeSingularInt32Field(value: &_storage._lazy) }()
+        case 564: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingComments) }()
+        case 565: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingDetachedComments) }()
+        case 566: try { try decoder.decodeSingularInt32Field(value: &_storage._length) }()
+        case 567: try { try decoder.decodeSingularInt32Field(value: &_storage._lessThan) }()
+        case 568: try { try decoder.decodeSingularInt32Field(value: &_storage._let) }()
+        case 569: try { try decoder.decodeSingularInt32Field(value: &_storage._lhs) }()
+        case 570: try { try decoder.decodeSingularInt32Field(value: &_storage._list) }()
+        case 571: try { try decoder.decodeSingularInt32Field(value: &_storage._listOfMessages) }()
+        case 572: try { try decoder.decodeSingularInt32Field(value: &_storage._listValue) }()
+        case 573: try { try decoder.decodeSingularInt32Field(value: &_storage._littleEndian) }()
+        case 574: try { try decoder.decodeSingularInt32Field(value: &_storage._littleEndianBytes) }()
+        case 575: try { try decoder.decodeSingularInt32Field(value: &_storage._load) }()
+        case 576: try { try decoder.decodeSingularInt32Field(value: &_storage._localHasher) }()
+        case 577: try { try decoder.decodeSingularInt32Field(value: &_storage._location) }()
+        case 578: try { try decoder.decodeSingularInt32Field(value: &_storage._m) }()
+        case 579: try { try decoder.decodeSingularInt32Field(value: &_storage._major) }()
+        case 580: try { try decoder.decodeSingularInt32Field(value: &_storage._makeAsyncIterator) }()
+        case 581: try { try decoder.decodeSingularInt32Field(value: &_storage._makeIterator) }()
+        case 582: try { try decoder.decodeSingularInt32Field(value: &_storage._map) }()
+        case 583: try { try decoder.decodeSingularInt32Field(value: &_storage._mapEntry) }()
+        case 584: try { try decoder.decodeSingularInt32Field(value: &_storage._mapKeyType) }()
+        case 585: try { try decoder.decodeSingularInt32Field(value: &_storage._mapToMessages) }()
+        case 586: try { try decoder.decodeSingularInt32Field(value: &_storage._mapValueType) }()
+        case 587: try { try decoder.decodeSingularInt32Field(value: &_storage._mapVisitor) }()
+        case 588: try { try decoder.decodeSingularInt32Field(value: &_storage._maximumEdition) }()
+        case 589: try { try decoder.decodeSingularInt32Field(value: &_storage._mdayStart) }()
+        case 590: try { try decoder.decodeSingularInt32Field(value: &_storage._merge) }()
+        case 591: try { try decoder.decodeSingularInt32Field(value: &_storage._message) }()
+        case 592: try { try decoder.decodeSingularInt32Field(value: &_storage._messageDepthLimit) }()
+        case 593: try { try decoder.decodeSingularInt32Field(value: &_storage._messageEncoding) }()
+        case 594: try { try decoder.decodeSingularInt32Field(value: &_storage._messageExtension) }()
+        case 595: try { try decoder.decodeSingularInt32Field(value: &_storage._messageImplementationBase) }()
+        case 596: try { try decoder.decodeSingularInt32Field(value: &_storage._messageOptions) }()
+        case 597: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSet) }()
+        case 598: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSetWireFormat) }()
+        case 599: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSize) }()
+        case 600: try { try decoder.decodeSingularInt32Field(value: &_storage._messageType) }()
+        case 601: try { try decoder.decodeSingularInt32Field(value: &_storage._method) }()
+        case 602: try { try decoder.decodeSingularInt32Field(value: &_storage._methodDescriptorProto) }()
+        case 603: try { try decoder.decodeSingularInt32Field(value: &_storage._methodOptions) }()
+        case 604: try { try decoder.decodeSingularInt32Field(value: &_storage._methods) }()
+        case 605: try { try decoder.decodeSingularInt32Field(value: &_storage._min) }()
+        case 606: try { try decoder.decodeSingularInt32Field(value: &_storage._minimumEdition) }()
+        case 607: try { try decoder.decodeSingularInt32Field(value: &_storage._minor) }()
+        case 608: try { try decoder.decodeSingularInt32Field(value: &_storage._mixin) }()
+        case 609: try { try decoder.decodeSingularInt32Field(value: &_storage._mixins) }()
+        case 610: try { try decoder.decodeSingularInt32Field(value: &_storage._modifier) }()
+        case 611: try { try decoder.decodeSingularInt32Field(value: &_storage._modify) }()
+        case 612: try { try decoder.decodeSingularInt32Field(value: &_storage._month) }()
+        case 613: try { try decoder.decodeSingularInt32Field(value: &_storage._msgExtension) }()
+        case 614: try { try decoder.decodeSingularInt32Field(value: &_storage._mutating) }()
+        case 615: try { try decoder.decodeSingularInt32Field(value: &_storage._n) }()
+        case 616: try { try decoder.decodeSingularInt32Field(value: &_storage._name) }()
+        case 617: try { try decoder.decodeSingularInt32Field(value: &_storage._nameDescription) }()
+        case 618: try { try decoder.decodeSingularInt32Field(value: &_storage._nameMap) }()
+        case 619: try { try decoder.decodeSingularInt32Field(value: &_storage._namePart) }()
+        case 620: try { try decoder.decodeSingularInt32Field(value: &_storage._names) }()
+        case 621: try { try decoder.decodeSingularInt32Field(value: &_storage._nanos) }()
+        case 622: try { try decoder.decodeSingularInt32Field(value: &_storage._negativeIntValue) }()
+        case 623: try { try decoder.decodeSingularInt32Field(value: &_storage._nestedType) }()
+        case 624: try { try decoder.decodeSingularInt32Field(value: &_storage._newL) }()
+        case 625: try { try decoder.decodeSingularInt32Field(value: &_storage._newList) }()
+        case 626: try { try decoder.decodeSingularInt32Field(value: &_storage._newValue) }()
+        case 627: try { try decoder.decodeSingularInt32Field(value: &_storage._next) }()
+        case 628: try { try decoder.decodeSingularInt32Field(value: &_storage._nextByte) }()
+        case 629: try { try decoder.decodeSingularInt32Field(value: &_storage._nextFieldNumber) }()
+        case 630: try { try decoder.decodeSingularInt32Field(value: &_storage._nextVarInt) }()
+        case 631: try { try decoder.decodeSingularInt32Field(value: &_storage._nil) }()
+        case 632: try { try decoder.decodeSingularInt32Field(value: &_storage._nilLiteral) }()
+        case 633: try { try decoder.decodeSingularInt32Field(value: &_storage._noStandardDescriptorAccessor) }()
+        case 634: try { try decoder.decodeSingularInt32Field(value: &_storage._nullValue) }()
+        case 635: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }()
+        case 636: try { try decoder.decodeSingularInt32Field(value: &_storage._numberValue) }()
+        case 637: try { try decoder.decodeSingularInt32Field(value: &_storage._objcClassPrefix) }()
+        case 638: try { try decoder.decodeSingularInt32Field(value: &_storage._of) }()
+        case 639: try { try decoder.decodeSingularInt32Field(value: &_storage._oneOf) }()
+        case 640: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofDecl) }()
+        case 641: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofDescriptorProto) }()
+        case 642: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofIndex) }()
+        case 643: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofOptions) }()
+        case 644: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofs) }()
+        case 645: try { try decoder.decodeSingularInt32Field(value: &_storage._oneOfKind) }()
+        case 646: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeFor) }()
+        case 647: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeMode) }()
+        case 648: try { try decoder.decodeSingularInt32Field(value: &_storage._option) }()
+        case 649: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalEnumExtensionField) }()
+        case 650: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalExtensionField) }()
+        case 651: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalGroupExtensionField) }()
+        case 652: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalMessageExtensionField) }()
+        case 653: try { try decoder.decodeSingularInt32Field(value: &_storage._optionRetention) }()
+        case 654: try { try decoder.decodeSingularInt32Field(value: &_storage._options) }()
+        case 655: try { try decoder.decodeSingularInt32Field(value: &_storage._optionTargetType) }()
+        case 656: try { try decoder.decodeSingularInt32Field(value: &_storage._other) }()
+        case 657: try { try decoder.decodeSingularInt32Field(value: &_storage._others) }()
+        case 658: try { try decoder.decodeSingularInt32Field(value: &_storage._out) }()
+        case 659: try { try decoder.decodeSingularInt32Field(value: &_storage._outputType) }()
+        case 660: try { try decoder.decodeSingularInt32Field(value: &_storage._p) }()
+        case 661: try { try decoder.decodeSingularInt32Field(value: &_storage._package) }()
+        case 662: try { try decoder.decodeSingularInt32Field(value: &_storage._packed) }()
+        case 663: try { try decoder.decodeSingularInt32Field(value: &_storage._packedBool) }()
+        case 664: try { try decoder.decodeSingularInt32Field(value: &_storage._packedDouble) }()
+        case 665: try { try decoder.decodeSingularInt32Field(value: &_storage._packedEnum) }()
+        case 666: try { try decoder.decodeSingularInt32Field(value: &_storage._packedEnumExtensionField) }()
+        case 667: try { try decoder.decodeSingularInt32Field(value: &_storage._packedExtensionField) }()
+        case 668: try { try decoder.decodeSingularInt32Field(value: &_storage._packedFixed32) }()
+        case 669: try { try decoder.decodeSingularInt32Field(value: &_storage._packedFixed64) }()
+        case 670: try { try decoder.decodeSingularInt32Field(value: &_storage._packedFloat) }()
+        case 671: try { try decoder.decodeSingularInt32Field(value: &_storage._packedInt32) }()
+        case 672: try { try decoder.decodeSingularInt32Field(value: &_storage._packedInt64) }()
+        case 673: try { try decoder.decodeSingularInt32Field(value: &_storage._packedSfixed32) }()
+        case 674: try { try decoder.decodeSingularInt32Field(value: &_storage._packedSfixed64) }()
+        case 675: try { try decoder.decodeSingularInt32Field(value: &_storage._packedSint32) }()
+        case 676: try { try decoder.decodeSingularInt32Field(value: &_storage._packedSint64) }()
+        case 677: try { try decoder.decodeSingularInt32Field(value: &_storage._packedUint32) }()
+        case 678: try { try decoder.decodeSingularInt32Field(value: &_storage._packedUint64) }()
+        case 679: try { try decoder.decodeSingularInt32Field(value: &_storage._padding) }()
+        case 680: try { try decoder.decodeSingularInt32Field(value: &_storage._parent) }()
+        case 681: try { try decoder.decodeSingularInt32Field(value: &_storage._parse) }()
+        case 682: try { try decoder.decodeSingularInt32Field(value: &_storage._path) }()
+        case 683: try { try decoder.decodeSingularInt32Field(value: &_storage._paths) }()
+        case 684: try { try decoder.decodeSingularInt32Field(value: &_storage._payload) }()
+        case 685: try { try decoder.decodeSingularInt32Field(value: &_storage._payloadSize) }()
+        case 686: try { try decoder.decodeSingularInt32Field(value: &_storage._phpClassPrefix) }()
+        case 687: try { try decoder.decodeSingularInt32Field(value: &_storage._phpGenericServices) }()
+        case 688: try { try decoder.decodeSingularInt32Field(value: &_storage._phpMetadataNamespace) }()
+        case 689: try { try decoder.decodeSingularInt32Field(value: &_storage._phpNamespace) }()
+        case 690: try { try decoder.decodeSingularInt32Field(value: &_storage._pos) }()
+        case 691: try { try decoder.decodeSingularInt32Field(value: &_storage._positiveIntValue) }()
+        case 692: try { try decoder.decodeSingularInt32Field(value: &_storage._prefix) }()
+        case 693: try { try decoder.decodeSingularInt32Field(value: &_storage._preserveProtoFieldNames) }()
+        case 694: try { try decoder.decodeSingularInt32Field(value: &_storage._preTraverse) }()
+        case 695: try { try decoder.decodeSingularInt32Field(value: &_storage._printUnknownFields) }()
+        case 696: try { try decoder.decodeSingularInt32Field(value: &_storage._proto2) }()
+        case 697: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3DefaultValue) }()
+        case 698: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3Optional) }()
+        case 699: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversionCheck) }()
+        case 700: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversion3) }()
+        case 701: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBool) }()
+        case 702: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBytes) }()
+        case 703: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufDouble) }()
+        case 704: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufEnumMap) }()
+        case 705: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtension) }()
+        case 706: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed32) }()
+        case 707: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed64) }()
+        case 708: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFloat) }()
+        case 709: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt32) }()
+        case 710: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt64) }()
+        case 711: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMap) }()
+        case 712: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMessageMap) }()
+        case 713: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed32) }()
+        case 714: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed64) }()
+        case 715: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint32) }()
+        case 716: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint64) }()
+        case 717: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufString) }()
+        case 718: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint32) }()
+        case 719: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint64) }()
+        case 720: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtensionFieldValues) }()
+        case 721: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFieldNumber) }()
+        case 722: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufGeneratedIsEqualTo) }()
+        case 723: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNameMap) }()
+        case 724: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNewField) }()
+        case 725: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufPackage) }()
+        case 726: try { try decoder.decodeSingularInt32Field(value: &_storage._protocol) }()
+        case 727: try { try decoder.decodeSingularInt32Field(value: &_storage._protoFieldName) }()
+        case 728: try { try decoder.decodeSingularInt32Field(value: &_storage._protoMessageName) }()
+        case 729: try { try decoder.decodeSingularInt32Field(value: &_storage._protoNameProviding) }()
+        case 730: try { try decoder.decodeSingularInt32Field(value: &_storage._protoPaths) }()
+        case 731: try { try decoder.decodeSingularInt32Field(value: &_storage._public) }()
+        case 732: try { try decoder.decodeSingularInt32Field(value: &_storage._publicDependency) }()
+        case 733: try { try decoder.decodeSingularInt32Field(value: &_storage._putBoolValue) }()
+        case 734: try { try decoder.decodeSingularInt32Field(value: &_storage._putBytesValue) }()
+        case 735: try { try decoder.decodeSingularInt32Field(value: &_storage._putDoubleValue) }()
+        case 736: try { try decoder.decodeSingularInt32Field(value: &_storage._putEnumValue) }()
+        case 737: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint32) }()
+        case 738: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint64) }()
+        case 739: try { try decoder.decodeSingularInt32Field(value: &_storage._putFloatValue) }()
+        case 740: try { try decoder.decodeSingularInt32Field(value: &_storage._putInt64) }()
+        case 741: try { try decoder.decodeSingularInt32Field(value: &_storage._putStringValue) }()
+        case 742: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64) }()
+        case 743: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64Hex) }()
+        case 744: try { try decoder.decodeSingularInt32Field(value: &_storage._putVarInt) }()
+        case 745: try { try decoder.decodeSingularInt32Field(value: &_storage._putZigZagVarInt) }()
+        case 746: try { try decoder.decodeSingularInt32Field(value: &_storage._pyGenericServices) }()
+        case 747: try { try decoder.decodeSingularInt32Field(value: &_storage._r) }()
+        case 748: try { try decoder.decodeSingularInt32Field(value: &_storage._rawChars) }()
+        case 749: try { try decoder.decodeSingularInt32Field(value: &_storage._rawRepresentable) }()
+        case 750: try { try decoder.decodeSingularInt32Field(value: &_storage._rawValue) }()
+        case 751: try { try decoder.decodeSingularInt32Field(value: &_storage._read4HexDigits) }()
+        case 752: try { try decoder.decodeSingularInt32Field(value: &_storage._readBytes) }()
+        case 753: try { try decoder.decodeSingularInt32Field(value: &_storage._register) }()
+        case 754: try { try decoder.decodeSingularInt32Field(value: &_storage._repeated) }()
+        case 755: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedBool) }()
+        case 756: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedBytes) }()
+        case 757: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedDouble) }()
+        case 758: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedEnum) }()
+        case 759: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedEnumExtensionField) }()
+        case 760: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedExtensionField) }()
+        case 761: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedFieldEncoding) }()
+        case 762: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedFixed32) }()
+        case 763: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedFixed64) }()
+        case 764: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedFloat) }()
+        case 765: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedGroup) }()
+        case 766: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedGroupExtensionField) }()
+        case 767: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedInt32) }()
+        case 768: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedInt64) }()
+        case 769: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedMessage) }()
+        case 770: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedMessageExtensionField) }()
+        case 771: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedSfixed32) }()
+        case 772: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedSfixed64) }()
+        case 773: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedSint32) }()
+        case 774: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedSint64) }()
+        case 775: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedString) }()
+        case 776: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedUint32) }()
+        case 777: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedUint64) }()
+        case 778: try { try decoder.decodeSingularInt32Field(value: &_storage._repeating) }()
+        case 779: try { try decoder.decodeSingularInt32Field(value: &_storage._requestStreaming) }()
+        case 780: try { try decoder.decodeSingularInt32Field(value: &_storage._requestTypeURL) }()
+        case 781: try { try decoder.decodeSingularInt32Field(value: &_storage._requiredSize) }()
+        case 782: try { try decoder.decodeSingularInt32Field(value: &_storage._responseStreaming) }()
+        case 783: try { try decoder.decodeSingularInt32Field(value: &_storage._responseTypeURL) }()
+        case 784: try { try decoder.decodeSingularInt32Field(value: &_storage._result) }()
+        case 785: try { try decoder.decodeSingularInt32Field(value: &_storage._retention) }()
+        case 786: try { try decoder.decodeSingularInt32Field(value: &_storage._rethrows) }()
+        case 787: try { try decoder.decodeSingularInt32Field(value: &_storage._return) }()
+        case 788: try { try decoder.decodeSingularInt32Field(value: &_storage._returnType) }()
+        case 789: try { try decoder.decodeSingularInt32Field(value: &_storage._revision) }()
+        case 790: try { try decoder.decodeSingularInt32Field(value: &_storage._rhs) }()
+        case 791: try { try decoder.decodeSingularInt32Field(value: &_storage._root) }()
+        case 792: try { try decoder.decodeSingularInt32Field(value: &_storage._rubyPackage) }()
+        case 793: try { try decoder.decodeSingularInt32Field(value: &_storage._s) }()
+        case 794: try { try decoder.decodeSingularInt32Field(value: &_storage._sawBackslash) }()
+        case 795: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection4Characters) }()
+        case 796: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection5Characters) }()
+        case 797: try { try decoder.decodeSingularInt32Field(value: &_storage._scanner) }()
+        case 798: try { try decoder.decodeSingularInt32Field(value: &_storage._seconds) }()
+        case 799: try { try decoder.decodeSingularInt32Field(value: &_storage._self_p) }()
+        case 800: try { try decoder.decodeSingularInt32Field(value: &_storage._semantic) }()
+        case 801: try { try decoder.decodeSingularInt32Field(value: &_storage._sendable) }()
+        case 802: try { try decoder.decodeSingularInt32Field(value: &_storage._separator) }()
+        case 803: try { try decoder.decodeSingularInt32Field(value: &_storage._serialize) }()
+        case 804: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedBytes) }()
+        case 805: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedData) }()
+        case 806: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedSize) }()
+        case 807: try { try decoder.decodeSingularInt32Field(value: &_storage._serverStreaming) }()
+        case 808: try { try decoder.decodeSingularInt32Field(value: &_storage._service) }()
+        case 809: try { try decoder.decodeSingularInt32Field(value: &_storage._serviceDescriptorProto) }()
+        case 810: try { try decoder.decodeSingularInt32Field(value: &_storage._serviceOptions) }()
+        case 811: try { try decoder.decodeSingularInt32Field(value: &_storage._set) }()
+        case 812: try { try decoder.decodeSingularInt32Field(value: &_storage._setExtensionValue) }()
+        case 813: try { try decoder.decodeSingularInt32Field(value: &_storage._shift) }()
+        case 814: try { try decoder.decodeSingularInt32Field(value: &_storage._simpleExtensionMap) }()
+        case 815: try { try decoder.decodeSingularInt32Field(value: &_storage._singularBool) }()
+        case 816: try { try decoder.decodeSingularInt32Field(value: &_storage._singularBytes) }()
+        case 817: try { try decoder.decodeSingularInt32Field(value: &_storage._singularDouble) }()
+        case 818: try { try decoder.decodeSingularInt32Field(value: &_storage._singularEnum) }()
+        case 819: try { try decoder.decodeSingularInt32Field(value: &_storage._singularFixed32) }()
+        case 820: try { try decoder.decodeSingularInt32Field(value: &_storage._singularFixed64) }()
+        case 821: try { try decoder.decodeSingularInt32Field(value: &_storage._singularFloat) }()
+        case 822: try { try decoder.decodeSingularInt32Field(value: &_storage._singularGroup) }()
+        case 823: try { try decoder.decodeSingularInt32Field(value: &_storage._singularInt32) }()
+        case 824: try { try decoder.decodeSingularInt32Field(value: &_storage._singularInt64) }()
+        case 825: try { try decoder.decodeSingularInt32Field(value: &_storage._singularMessage) }()
+        case 826: try { try decoder.decodeSingularInt32Field(value: &_storage._singularSfixed32) }()
+        case 827: try { try decoder.decodeSingularInt32Field(value: &_storage._singularSfixed64) }()
+        case 828: try { try decoder.decodeSingularInt32Field(value: &_storage._singularSint32) }()
+        case 829: try { try decoder.decodeSingularInt32Field(value: &_storage._singularSint64) }()
+        case 830: try { try decoder.decodeSingularInt32Field(value: &_storage._singularString) }()
+        case 831: try { try decoder.decodeSingularInt32Field(value: &_storage._singularUint32) }()
+        case 832: try { try decoder.decodeSingularInt32Field(value: &_storage._singularUint64) }()
+        case 833: try { try decoder.decodeSingularInt32Field(value: &_storage._size) }()
+        case 834: try { try decoder.decodeSingularInt32Field(value: &_storage._sizer) }()
+        case 835: try { try decoder.decodeSingularInt32Field(value: &_storage._source) }()
+        case 836: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceCodeInfo) }()
+        case 837: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceContext) }()
+        case 838: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceEncoding) }()
+        case 839: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceFile) }()
+        case 840: try { try decoder.decodeSingularInt32Field(value: &_storage._span) }()
+        case 841: try { try decoder.decodeSingularInt32Field(value: &_storage._split) }()
+        case 842: try { try decoder.decodeSingularInt32Field(value: &_storage._start) }()
+        case 843: try { try decoder.decodeSingularInt32Field(value: &_storage._startArray) }()
+        case 844: try { try decoder.decodeSingularInt32Field(value: &_storage._startArrayObject) }()
+        case 845: try { try decoder.decodeSingularInt32Field(value: &_storage._startField) }()
+        case 846: try { try decoder.decodeSingularInt32Field(value: &_storage._startIndex) }()
+        case 847: try { try decoder.decodeSingularInt32Field(value: &_storage._startMessageField) }()
+        case 848: try { try decoder.decodeSingularInt32Field(value: &_storage._startObject) }()
+        case 849: try { try decoder.decodeSingularInt32Field(value: &_storage._startRegularField) }()
+        case 850: try { try decoder.decodeSingularInt32Field(value: &_storage._state) }()
+        case 851: try { try decoder.decodeSingularInt32Field(value: &_storage._static) }()
+        case 852: try { try decoder.decodeSingularInt32Field(value: &_storage._staticString) }()
+        case 853: try { try decoder.decodeSingularInt32Field(value: &_storage._storage) }()
+        case 854: try { try decoder.decodeSingularInt32Field(value: &_storage._string) }()
+        case 855: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteral) }()
+        case 856: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteralType) }()
+        case 857: try { try decoder.decodeSingularInt32Field(value: &_storage._stringResult) }()
+        case 858: try { try decoder.decodeSingularInt32Field(value: &_storage._stringValue) }()
+        case 859: try { try decoder.decodeSingularInt32Field(value: &_storage._struct) }()
+        case 860: try { try decoder.decodeSingularInt32Field(value: &_storage._structValue) }()
+        case 861: try { try decoder.decodeSingularInt32Field(value: &_storage._subDecoder) }()
+        case 862: try { try decoder.decodeSingularInt32Field(value: &_storage._subscript) }()
+        case 863: try { try decoder.decodeSingularInt32Field(value: &_storage._subVisitor) }()
+        case 864: try { try decoder.decodeSingularInt32Field(value: &_storage._swift) }()
+        case 865: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftPrefix) }()
+        case 866: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftProtobufContiguousBytes) }()
+        case 867: try { try decoder.decodeSingularInt32Field(value: &_storage._syntax) }()
+        case 868: try { try decoder.decodeSingularInt32Field(value: &_storage._t) }()
+        case 869: try { try decoder.decodeSingularInt32Field(value: &_storage._tag) }()
+        case 870: try { try decoder.decodeSingularInt32Field(value: &_storage._targets) }()
+        case 871: try { try decoder.decodeSingularInt32Field(value: &_storage._terminator) }()
+        case 872: try { try decoder.decodeSingularInt32Field(value: &_storage._testDecoder) }()
+        case 873: try { try decoder.decodeSingularInt32Field(value: &_storage._text) }()
+        case 874: try { try decoder.decodeSingularInt32Field(value: &_storage._textDecoder) }()
+        case 875: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecoder) }()
+        case 876: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingError) }()
+        case 877: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingOptions) }()
+        case 878: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingOptions) }()
+        case 879: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingVisitor) }()
+        case 880: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatString) }()
+        case 881: try { try decoder.decodeSingularInt32Field(value: &_storage._throwOrIgnore) }()
+        case 882: try { try decoder.decodeSingularInt32Field(value: &_storage._throws) }()
+        case 883: try { try decoder.decodeSingularInt32Field(value: &_storage._timeInterval) }()
+        case 884: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSince1970) }()
+        case 885: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSinceReferenceDate) }()
+        case 886: try { try decoder.decodeSingularInt32Field(value: &_storage._timestamp) }()
+        case 887: try { try decoder.decodeSingularInt32Field(value: &_storage._toConcrete) }()
+        case 888: try { try decoder.decodeSingularInt32Field(value: &_storage._total) }()
+        case 889: try { try decoder.decodeSingularInt32Field(value: &_storage._totalArrayDepth) }()
+        case 890: try { try decoder.decodeSingularInt32Field(value: &_storage._totalSize) }()
+        case 891: try { try decoder.decodeSingularInt32Field(value: &_storage._trailingComments) }()
+        case 892: try { try decoder.decodeSingularInt32Field(value: &_storage._traverse) }()
+        case 893: try { try decoder.decodeSingularInt32Field(value: &_storage._true) }()
+        case 894: try { try decoder.decodeSingularInt32Field(value: &_storage._try) }()
+        case 895: try { try decoder.decodeSingularInt32Field(value: &_storage._type) }()
+        case 896: try { try decoder.decodeSingularInt32Field(value: &_storage._typealias) }()
+        case 897: try { try decoder.decodeSingularInt32Field(value: &_storage._typeEnum) }()
+        case 898: try { try decoder.decodeSingularInt32Field(value: &_storage._typeName) }()
+        case 899: try { try decoder.decodeSingularInt32Field(value: &_storage._typePrefix) }()
+        case 900: try { try decoder.decodeSingularInt32Field(value: &_storage._typeStart) }()
+        case 901: try { try decoder.decodeSingularInt32Field(value: &_storage._typeUnknown) }()
+        case 902: try { try decoder.decodeSingularInt32Field(value: &_storage._typeURL) }()
+        case 903: try { try decoder.decodeSingularInt32Field(value: &_storage._uint32) }()
+        case 904: try { try decoder.decodeSingularInt32Field(value: &_storage._uint32Value) }()
+        case 905: try { try decoder.decodeSingularInt32Field(value: &_storage._uint64) }()
+        case 906: try { try decoder.decodeSingularInt32Field(value: &_storage._uint64Value) }()
+        case 907: try { try decoder.decodeSingularInt32Field(value: &_storage._uint8) }()
+        case 908: try { try decoder.decodeSingularInt32Field(value: &_storage._unchecked) }()
+        case 909: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteral) }()
+        case 910: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteralType) }()
+        case 911: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalars) }()
+        case 912: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarView) }()
+        case 913: try { try decoder.decodeSingularInt32Field(value: &_storage._uninterpretedOption) }()
+        case 914: try { try decoder.decodeSingularInt32Field(value: &_storage._union) }()
+        case 915: try { try decoder.decodeSingularInt32Field(value: &_storage._uniqueStorage) }()
+        case 916: try { try decoder.decodeSingularInt32Field(value: &_storage._unknown) }()
+        case 917: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownFields_p) }()
+        case 918: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownStorage) }()
+        case 919: try { try decoder.decodeSingularInt32Field(value: &_storage._unpackTo) }()
+        case 920: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeBufferPointer) }()
+        case 921: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutablePointer) }()
+        case 922: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutableRawBufferPointer) }()
+        case 923: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawBufferPointer) }()
+        case 924: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawPointer) }()
+        case 925: try { try decoder.decodeSingularInt32Field(value: &_storage._unverifiedLazy) }()
+        case 926: try { try decoder.decodeSingularInt32Field(value: &_storage._updatedOptions) }()
+        case 927: try { try decoder.decodeSingularInt32Field(value: &_storage._url) }()
+        case 928: try { try decoder.decodeSingularInt32Field(value: &_storage._useDeterministicOrdering) }()
+        case 929: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8) }()
+        case 930: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8Ptr) }()
+        case 931: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8ToDouble) }()
+        case 932: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8Validation) }()
+        case 933: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8View) }()
+        case 934: try { try decoder.decodeSingularInt32Field(value: &_storage._v) }()
+        case 935: try { try decoder.decodeSingularInt32Field(value: &_storage._value) }()
+        case 936: try { try decoder.decodeSingularInt32Field(value: &_storage._valueField) }()
+        case 937: try { try decoder.decodeSingularInt32Field(value: &_storage._values) }()
+        case 938: try { try decoder.decodeSingularInt32Field(value: &_storage._valueType) }()
+        case 939: try { try decoder.decodeSingularInt32Field(value: &_storage._var) }()
+        case 940: try { try decoder.decodeSingularInt32Field(value: &_storage._verification) }()
+        case 941: try { try decoder.decodeSingularInt32Field(value: &_storage._verificationState) }()
+        case 942: try { try decoder.decodeSingularInt32Field(value: &_storage._version) }()
+        case 943: try { try decoder.decodeSingularInt32Field(value: &_storage._versionString) }()
+        case 944: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFields) }()
+        case 945: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFieldsAsMessageSet) }()
+        case 946: try { try decoder.decodeSingularInt32Field(value: &_storage._visitMapField) }()
+        case 947: try { try decoder.decodeSingularInt32Field(value: &_storage._visitor) }()
+        case 948: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPacked) }()
+        case 949: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedBoolField) }()
+        case 950: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedDoubleField) }()
+        case 951: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedEnumField) }()
+        case 952: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed32Field) }()
+        case 953: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed64Field) }()
+        case 954: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFloatField) }()
+        case 955: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt32Field) }()
+        case 956: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt64Field) }()
+        case 957: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed32Field) }()
+        case 958: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed64Field) }()
+        case 959: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint32Field) }()
+        case 960: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint64Field) }()
+        case 961: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint32Field) }()
+        case 962: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint64Field) }()
+        case 963: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeated) }()
+        case 964: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBoolField) }()
+        case 965: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBytesField) }()
+        case 966: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedDoubleField) }()
+        case 967: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedEnumField) }()
+        case 968: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed32Field) }()
+        case 969: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed64Field) }()
+        case 970: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFloatField) }()
+        case 971: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedGroupField) }()
+        case 972: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt32Field) }()
+        case 973: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt64Field) }()
+        case 974: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedMessageField) }()
+        case 975: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed32Field) }()
+        case 976: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed64Field) }()
+        case 977: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint32Field) }()
+        case 978: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint64Field) }()
+        case 979: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedStringField) }()
+        case 980: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint32Field) }()
+        case 981: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint64Field) }()
+        case 982: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingular) }()
+        case 983: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBoolField) }()
+        case 984: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBytesField) }()
+        case 985: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularDoubleField) }()
+        case 986: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularEnumField) }()
+        case 987: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed32Field) }()
+        case 988: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed64Field) }()
+        case 989: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFloatField) }()
+        case 990: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularGroupField) }()
+        case 991: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt32Field) }()
+        case 992: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt64Field) }()
+        case 993: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularMessageField) }()
+        case 994: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed32Field) }()
+        case 995: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed64Field) }()
+        case 996: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint32Field) }()
+        case 997: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint64Field) }()
+        case 998: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularStringField) }()
+        case 999: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint32Field) }()
+        case 1000: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint64Field) }()
+        case 1001: try { try decoder.decodeSingularInt32Field(value: &_storage._visitUnknown) }()
+        case 1002: try { try decoder.decodeSingularInt32Field(value: &_storage._wasDecoded) }()
+        case 1003: try { try decoder.decodeSingularInt32Field(value: &_storage._weak) }()
+        case 1004: try { try decoder.decodeSingularInt32Field(value: &_storage._weakDependency) }()
+        case 1005: try { try decoder.decodeSingularInt32Field(value: &_storage._where) }()
+        case 1006: try { try decoder.decodeSingularInt32Field(value: &_storage._wireFormat) }()
+        case 1007: try { try decoder.decodeSingularInt32Field(value: &_storage._with) }()
+        case 1008: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeBytes) }()
+        case 1009: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeMutableBytes) }()
+        case 1010: try { try decoder.decodeSingularInt32Field(value: &_storage._work) }()
+        case 1011: try { try decoder.decodeSingularInt32Field(value: &_storage._wrapped) }()
+        case 1012: try { try decoder.decodeSingularInt32Field(value: &_storage._wrappedType) }()
+        case 1013: try { try decoder.decodeSingularInt32Field(value: &_storage._wrappedValue) }()
+        case 1014: try { try decoder.decodeSingularInt32Field(value: &_storage._written) }()
+        case 1015: try { try decoder.decodeSingularInt32Field(value: &_storage._yday) }()
         default: break
         }
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      if _storage._adjusted != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._adjusted, fieldNumber: 1)
-      }
-      if _storage._aggregateValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._aggregateValue, fieldNumber: 2)
-      }
-      if _storage._allCases != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._allCases, fieldNumber: 3)
-      }
-      if _storage._allowAlias != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._allowAlias, fieldNumber: 4)
-      }
-      if _storage._alwaysPrintEnumsAsInts != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._alwaysPrintEnumsAsInts, fieldNumber: 5)
-      }
-      if _storage._alwaysPrintInt64SAsNumbers != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._alwaysPrintInt64SAsNumbers, fieldNumber: 6)
-      }
-      if _storage._annotation != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._annotation, fieldNumber: 7)
-      }
-      if _storage._any != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._any, fieldNumber: 8)
-      }
-      if _storage._anyExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._anyExtensionField, fieldNumber: 9)
-      }
-      if _storage._anyMessageExtension != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._anyMessageExtension, fieldNumber: 10)
-      }
-      if _storage._anyMessageStorage != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._anyMessageStorage, fieldNumber: 11)
-      }
-      if _storage._anyUnpackError != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._anyUnpackError, fieldNumber: 12)
-      }
-      if _storage._api != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._api, fieldNumber: 13)
-      }
-      if _storage._appended != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._appended, fieldNumber: 14)
-      }
-      if _storage._appendUintHex != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._appendUintHex, fieldNumber: 15)
-      }
-      if _storage._appendUnknown != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._appendUnknown, fieldNumber: 16)
-      }
-      if _storage._areAllInitialized != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._areAllInitialized, fieldNumber: 17)
-      }
-      if _storage._array != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._array, fieldNumber: 18)
-      }
-      if _storage._arrayDepth != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._arrayDepth, fieldNumber: 19)
-      }
-      if _storage._arrayLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._arrayLiteral, fieldNumber: 20)
-      }
-      if _storage._arraySeparator != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._arraySeparator, fieldNumber: 21)
-      }
-      if _storage._as != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._as, fieldNumber: 22)
-      }
-      if _storage._asciiOpenCurlyBracket != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._asciiOpenCurlyBracket, fieldNumber: 23)
-      }
-      if _storage._asciiZero != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._asciiZero, fieldNumber: 24)
-      }
-      if _storage._async != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._async, fieldNumber: 25)
-      }
-      if _storage._asyncIterator != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._asyncIterator, fieldNumber: 26)
-      }
-      if _storage._asyncIteratorProtocol != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._asyncIteratorProtocol, fieldNumber: 27)
-      }
-      if _storage._asyncMessageSequence != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._asyncMessageSequence, fieldNumber: 28)
-      }
-      if _storage._available != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._available, fieldNumber: 29)
-      }
-      if _storage._b != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._b, fieldNumber: 30)
-      }
-      if _storage._base != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._base, fieldNumber: 31)
-      }
-      if _storage._base64Values != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._base64Values, fieldNumber: 32)
-      }
-      if _storage._baseAddress != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._baseAddress, fieldNumber: 33)
-      }
-      if _storage._baseType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._baseType, fieldNumber: 34)
-      }
-      if _storage._begin != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._begin, fieldNumber: 35)
-      }
-      if _storage._binary != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binary, fieldNumber: 36)
-      }
-      if _storage._binaryDecoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryDecoder, fieldNumber: 37)
-      }
-      if _storage._binaryDecodingError != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryDecodingError, fieldNumber: 38)
-      }
-      if _storage._binaryDecodingOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryDecodingOptions, fieldNumber: 39)
-      }
-      if _storage._binaryDelimited != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryDelimited, fieldNumber: 40)
-      }
-      if _storage._binaryEncoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryEncoder, fieldNumber: 41)
-      }
-      if _storage._binaryEncodingError != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryEncodingError, fieldNumber: 42)
-      }
-      if _storage._binaryEncodingMessageSetSizeVisitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryEncodingMessageSetSizeVisitor, fieldNumber: 43)
-      }
-      if _storage._binaryEncodingMessageSetVisitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryEncodingMessageSetVisitor, fieldNumber: 44)
-      }
-      if _storage._binaryEncodingOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryEncodingOptions, fieldNumber: 45)
-      }
-      if _storage._binaryEncodingSizeVisitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryEncodingSizeVisitor, fieldNumber: 46)
-      }
-      if _storage._binaryEncodingVisitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryEncodingVisitor, fieldNumber: 47)
-      }
-      if _storage._binaryOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryOptions, fieldNumber: 48)
-      }
-      if _storage._binaryProtobufDelimitedMessages != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._binaryProtobufDelimitedMessages, fieldNumber: 49)
-      }
-      if _storage._bitPattern != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._bitPattern, fieldNumber: 50)
-      }
-      if _storage._body != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._body, fieldNumber: 51)
-      }
-      if _storage._bool != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._bool, fieldNumber: 52)
-      }
-      if _storage._booleanLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._booleanLiteral, fieldNumber: 53)
-      }
-      if _storage._booleanLiteralType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._booleanLiteralType, fieldNumber: 54)
-      }
-      if _storage._boolValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._boolValue, fieldNumber: 55)
-      }
-      if _storage._buffer != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._buffer, fieldNumber: 56)
-      }
-      if _storage._bytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._bytes, fieldNumber: 57)
-      }
-      if _storage._bytesInGroup != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._bytesInGroup, fieldNumber: 58)
-      }
-      if _storage._bytesNeeded != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._bytesNeeded, fieldNumber: 59)
-      }
-      if _storage._bytesRead != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._bytesRead, fieldNumber: 60)
-      }
-      if _storage._bytesValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._bytesValue, fieldNumber: 61)
-      }
-      if _storage._c != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._c, fieldNumber: 62)
-      }
-      if _storage._capitalizeNext != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._capitalizeNext, fieldNumber: 63)
-      }
-      if _storage._cardinality != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._cardinality, fieldNumber: 64)
-      }
-      if _storage._caseIterable != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._caseIterable, fieldNumber: 65)
-      }
-      if _storage._ccEnableArenas != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._ccEnableArenas, fieldNumber: 66)
-      }
-      if _storage._ccGenericServices != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._ccGenericServices, fieldNumber: 67)
-      }
-      if _storage._character != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._character, fieldNumber: 68)
-      }
-      if _storage._chars != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._chars, fieldNumber: 69)
-      }
-      if _storage._chunk != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._chunk, fieldNumber: 70)
-      }
-      if _storage._class != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._class, fieldNumber: 71)
-      }
-      if _storage._clearAggregateValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearAggregateValue_p, fieldNumber: 72)
-      }
-      if _storage._clearAllowAlias_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearAllowAlias_p, fieldNumber: 73)
-      }
-      if _storage._clearBegin_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearBegin_p, fieldNumber: 74)
-      }
-      if _storage._clearCcEnableArenas_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearCcEnableArenas_p, fieldNumber: 75)
-      }
-      if _storage._clearCcGenericServices_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearCcGenericServices_p, fieldNumber: 76)
-      }
-      if _storage._clearClientStreaming_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearClientStreaming_p, fieldNumber: 77)
-      }
-      if _storage._clearCsharpNamespace_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearCsharpNamespace_p, fieldNumber: 78)
-      }
-      if _storage._clearCtype_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearCtype_p, fieldNumber: 79)
-      }
-      if _storage._clearDebugRedact_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearDebugRedact_p, fieldNumber: 80)
-      }
-      if _storage._clearDefaultValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearDefaultValue_p, fieldNumber: 81)
-      }
-      if _storage._clearDeprecated_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearDeprecated_p, fieldNumber: 82)
-      }
-      if _storage._clearDeprecatedLegacyJsonFieldConflicts_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 83)
-      }
-      if _storage._clearDoubleValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearDoubleValue_p, fieldNumber: 84)
-      }
-      if _storage._clearEdition_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearEdition_p, fieldNumber: 85)
-      }
-      if _storage._clearEnd_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearEnd_p, fieldNumber: 86)
-      }
-      if _storage._clearEnumType_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearEnumType_p, fieldNumber: 87)
-      }
-      if _storage._clearExtendee_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearExtendee_p, fieldNumber: 88)
-      }
-      if _storage._clearExtensionValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearExtensionValue_p, fieldNumber: 89)
-      }
-      if _storage._clearFeatures_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearFeatures_p, fieldNumber: 90)
-      }
-      if _storage._clearFieldPresence_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearFieldPresence_p, fieldNumber: 91)
-      }
-      if _storage._clearFullName_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearFullName_p, fieldNumber: 92)
-      }
-      if _storage._clearGoPackage_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearGoPackage_p, fieldNumber: 93)
-      }
-      if _storage._clearIdempotencyLevel_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearIdempotencyLevel_p, fieldNumber: 94)
-      }
-      if _storage._clearIdentifierValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearIdentifierValue_p, fieldNumber: 95)
-      }
-      if _storage._clearInputType_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearInputType_p, fieldNumber: 96)
-      }
-      if _storage._clearIsExtension_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearIsExtension_p, fieldNumber: 97)
-      }
-      if _storage._clearJavaGenerateEqualsAndHash_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearJavaGenerateEqualsAndHash_p, fieldNumber: 98)
-      }
-      if _storage._clearJavaGenericServices_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearJavaGenericServices_p, fieldNumber: 99)
-      }
-      if _storage._clearJavaMultipleFiles_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearJavaMultipleFiles_p, fieldNumber: 100)
-      }
-      if _storage._clearJavaOuterClassname_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearJavaOuterClassname_p, fieldNumber: 101)
-      }
-      if _storage._clearJavaPackage_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearJavaPackage_p, fieldNumber: 102)
-      }
-      if _storage._clearJavaStringCheckUtf8_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearJavaStringCheckUtf8_p, fieldNumber: 103)
-      }
-      if _storage._clearJsonFormat_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearJsonFormat_p, fieldNumber: 104)
-      }
-      if _storage._clearJsonName_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearJsonName_p, fieldNumber: 105)
-      }
-      if _storage._clearJstype_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearJstype_p, fieldNumber: 106)
-      }
-      if _storage._clearLabel_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearLabel_p, fieldNumber: 107)
-      }
-      if _storage._clearLazy_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearLazy_p, fieldNumber: 108)
-      }
-      if _storage._clearLeadingComments_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearLeadingComments_p, fieldNumber: 109)
-      }
-      if _storage._clearMapEntry_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearMapEntry_p, fieldNumber: 110)
-      }
-      if _storage._clearMaximumEdition_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearMaximumEdition_p, fieldNumber: 111)
-      }
-      if _storage._clearMessageEncoding_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearMessageEncoding_p, fieldNumber: 112)
-      }
-      if _storage._clearMessageSetWireFormat_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearMessageSetWireFormat_p, fieldNumber: 113)
-      }
-      if _storage._clearMinimumEdition_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearMinimumEdition_p, fieldNumber: 114)
-      }
-      if _storage._clearName_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearName_p, fieldNumber: 115)
-      }
-      if _storage._clearNamePart_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearNamePart_p, fieldNumber: 116)
-      }
-      if _storage._clearNegativeIntValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearNegativeIntValue_p, fieldNumber: 117)
-      }
-      if _storage._clearNoStandardDescriptorAccessor_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearNoStandardDescriptorAccessor_p, fieldNumber: 118)
-      }
-      if _storage._clearNumber_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearNumber_p, fieldNumber: 119)
-      }
-      if _storage._clearObjcClassPrefix_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearObjcClassPrefix_p, fieldNumber: 120)
-      }
-      if _storage._clearOneofIndex_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearOneofIndex_p, fieldNumber: 121)
-      }
-      if _storage._clearOptimizeFor_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearOptimizeFor_p, fieldNumber: 122)
-      }
-      if _storage._clearOptions_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearOptions_p, fieldNumber: 123)
-      }
-      if _storage._clearOutputType_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearOutputType_p, fieldNumber: 124)
-      }
-      if _storage._clearPackage_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearPackage_p, fieldNumber: 125)
-      }
-      if _storage._clearPacked_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearPacked_p, fieldNumber: 126)
-      }
-      if _storage._clearPhpClassPrefix_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearPhpClassPrefix_p, fieldNumber: 127)
-      }
-      if _storage._clearPhpGenericServices_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearPhpGenericServices_p, fieldNumber: 128)
-      }
-      if _storage._clearPhpMetadataNamespace_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearPhpMetadataNamespace_p, fieldNumber: 129)
-      }
-      if _storage._clearPhpNamespace_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearPhpNamespace_p, fieldNumber: 130)
-      }
-      if _storage._clearPositiveIntValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearPositiveIntValue_p, fieldNumber: 131)
-      }
-      if _storage._clearProto3Optional_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearProto3Optional_p, fieldNumber: 132)
-      }
-      if _storage._clearPyGenericServices_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearPyGenericServices_p, fieldNumber: 133)
-      }
-      if _storage._clearRepeated_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearRepeated_p, fieldNumber: 134)
-      }
-      if _storage._clearRepeatedFieldEncoding_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearRepeatedFieldEncoding_p, fieldNumber: 135)
-      }
-      if _storage._clearReserved_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearReserved_p, fieldNumber: 136)
-      }
-      if _storage._clearRetention_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearRetention_p, fieldNumber: 137)
-      }
-      if _storage._clearRubyPackage_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearRubyPackage_p, fieldNumber: 138)
-      }
-      if _storage._clearSemantic_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearSemantic_p, fieldNumber: 139)
-      }
-      if _storage._clearServerStreaming_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearServerStreaming_p, fieldNumber: 140)
-      }
-      if _storage._clearSourceCodeInfo_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearSourceCodeInfo_p, fieldNumber: 141)
-      }
-      if _storage._clearSourceContext_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearSourceContext_p, fieldNumber: 142)
-      }
-      if _storage._clearSourceFile_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearSourceFile_p, fieldNumber: 143)
-      }
-      if _storage._clearStart_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearStart_p, fieldNumber: 144)
-      }
-      if _storage._clearStringValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearStringValue_p, fieldNumber: 145)
-      }
-      if _storage._clearSwiftPrefix_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearSwiftPrefix_p, fieldNumber: 146)
-      }
-      if _storage._clearSyntax_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearSyntax_p, fieldNumber: 147)
-      }
-      if _storage._clearTrailingComments_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearTrailingComments_p, fieldNumber: 148)
-      }
-      if _storage._clearType_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearType_p, fieldNumber: 149)
-      }
-      if _storage._clearTypeName_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearTypeName_p, fieldNumber: 150)
-      }
-      if _storage._clearUnverifiedLazy_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearUnverifiedLazy_p, fieldNumber: 151)
-      }
-      if _storage._clearUtf8Validation_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearUtf8Validation_p, fieldNumber: 152)
-      }
-      if _storage._clearValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearValue_p, fieldNumber: 153)
-      }
-      if _storage._clearVerification_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearVerification_p, fieldNumber: 154)
-      }
-      if _storage._clearWeak_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clearWeak_p, fieldNumber: 155)
-      }
-      if _storage._clientStreaming != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._clientStreaming, fieldNumber: 156)
-      }
-      if _storage._codePoint != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._codePoint, fieldNumber: 157)
-      }
-      if _storage._codeUnits != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._codeUnits, fieldNumber: 158)
-      }
-      if _storage._collection != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._collection, fieldNumber: 159)
-      }
-      if _storage._com != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._com, fieldNumber: 160)
-      }
-      if _storage._comma != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._comma, fieldNumber: 161)
-      }
-      if _storage._commonMessageConformances != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._commonMessageConformances, fieldNumber: 162)
-      }
-      if _storage._consumedBytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._consumedBytes, fieldNumber: 163)
-      }
-      if _storage._contentsOf != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._contentsOf, fieldNumber: 164)
-      }
-      if _storage._count != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._count, fieldNumber: 165)
-      }
-      if _storage._countVarintsInBuffer != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._countVarintsInBuffer, fieldNumber: 166)
-      }
-      if _storage._csharpNamespace != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._csharpNamespace, fieldNumber: 167)
-      }
-      if _storage._ctype != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._ctype, fieldNumber: 168)
-      }
-      if _storage._customCodable != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._customCodable, fieldNumber: 169)
-      }
-      if _storage._d != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._d, fieldNumber: 170)
-      }
-      if _storage._data != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._data, fieldNumber: 171)
-      }
-      if _storage._dataResult != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._dataResult, fieldNumber: 172)
-      }
-      if _storage._date != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._date, fieldNumber: 173)
-      }
-      if _storage._daySec != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._daySec, fieldNumber: 174)
-      }
-      if _storage._daysSinceEpoch != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._daysSinceEpoch, fieldNumber: 175)
-      }
-      if _storage._debugDescription_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._debugDescription_p, fieldNumber: 176)
-      }
-      if _storage._debugRedact != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._debugRedact, fieldNumber: 177)
-      }
-      if _storage._declaration != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._declaration, fieldNumber: 178)
-      }
-      if _storage._decoded != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decoded, fieldNumber: 179)
-      }
-      if _storage._decodedFromJsonnull != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodedFromJsonnull, fieldNumber: 180)
-      }
-      if _storage._decodeExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeExtensionField, fieldNumber: 181)
-      }
-      if _storage._decodeExtensionFieldsAsMessageSet != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeExtensionFieldsAsMessageSet, fieldNumber: 182)
-      }
-      if _storage._decodeJson != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeJson, fieldNumber: 183)
-      }
-      if _storage._decodeMapField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeMapField, fieldNumber: 184)
-      }
-      if _storage._decodeMessage != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeMessage, fieldNumber: 185)
-      }
-      if _storage._decoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decoder, fieldNumber: 186)
-      }
-      if _storage._decodeRepeated != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeated, fieldNumber: 187)
-      }
-      if _storage._decodeRepeatedBoolField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedBoolField, fieldNumber: 188)
-      }
-      if _storage._decodeRepeatedBytesField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedBytesField, fieldNumber: 189)
-      }
-      if _storage._decodeRepeatedDoubleField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedDoubleField, fieldNumber: 190)
-      }
-      if _storage._decodeRepeatedEnumField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedEnumField, fieldNumber: 191)
-      }
-      if _storage._decodeRepeatedFixed32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFixed32Field, fieldNumber: 192)
-      }
-      if _storage._decodeRepeatedFixed64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFixed64Field, fieldNumber: 193)
-      }
-      if _storage._decodeRepeatedFloatField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFloatField, fieldNumber: 194)
-      }
-      if _storage._decodeRepeatedGroupField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedGroupField, fieldNumber: 195)
-      }
-      if _storage._decodeRepeatedInt32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedInt32Field, fieldNumber: 196)
-      }
-      if _storage._decodeRepeatedInt64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedInt64Field, fieldNumber: 197)
-      }
-      if _storage._decodeRepeatedMessageField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedMessageField, fieldNumber: 198)
-      }
-      if _storage._decodeRepeatedSfixed32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSfixed32Field, fieldNumber: 199)
-      }
-      if _storage._decodeRepeatedSfixed64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSfixed64Field, fieldNumber: 200)
-      }
-      if _storage._decodeRepeatedSint32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSint32Field, fieldNumber: 201)
-      }
-      if _storage._decodeRepeatedSint64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSint64Field, fieldNumber: 202)
-      }
-      if _storage._decodeRepeatedStringField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedStringField, fieldNumber: 203)
-      }
-      if _storage._decodeRepeatedUint32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedUint32Field, fieldNumber: 204)
-      }
-      if _storage._decodeRepeatedUint64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedUint64Field, fieldNumber: 205)
-      }
-      if _storage._decodeSingular != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingular, fieldNumber: 206)
-      }
-      if _storage._decodeSingularBoolField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularBoolField, fieldNumber: 207)
-      }
-      if _storage._decodeSingularBytesField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularBytesField, fieldNumber: 208)
-      }
-      if _storage._decodeSingularDoubleField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularDoubleField, fieldNumber: 209)
-      }
-      if _storage._decodeSingularEnumField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularEnumField, fieldNumber: 210)
-      }
-      if _storage._decodeSingularFixed32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularFixed32Field, fieldNumber: 211)
-      }
-      if _storage._decodeSingularFixed64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularFixed64Field, fieldNumber: 212)
-      }
-      if _storage._decodeSingularFloatField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularFloatField, fieldNumber: 213)
-      }
-      if _storage._decodeSingularGroupField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularGroupField, fieldNumber: 214)
-      }
-      if _storage._decodeSingularInt32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularInt32Field, fieldNumber: 215)
-      }
-      if _storage._decodeSingularInt64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularInt64Field, fieldNumber: 216)
-      }
-      if _storage._decodeSingularMessageField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularMessageField, fieldNumber: 217)
-      }
-      if _storage._decodeSingularSfixed32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularSfixed32Field, fieldNumber: 218)
-      }
-      if _storage._decodeSingularSfixed64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularSfixed64Field, fieldNumber: 219)
-      }
-      if _storage._decodeSingularSint32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularSint32Field, fieldNumber: 220)
-      }
-      if _storage._decodeSingularSint64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularSint64Field, fieldNumber: 221)
-      }
-      if _storage._decodeSingularStringField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularStringField, fieldNumber: 222)
-      }
-      if _storage._decodeSingularUint32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularUint32Field, fieldNumber: 223)
-      }
-      if _storage._decodeSingularUint64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeSingularUint64Field, fieldNumber: 224)
-      }
-      if _storage._decodeTextFormat != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._decodeTextFormat, fieldNumber: 225)
-      }
-      if _storage._defaultAnyTypeUrlprefix != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._defaultAnyTypeUrlprefix, fieldNumber: 226)
-      }
-      if _storage._defaults != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._defaults, fieldNumber: 227)
-      }
-      if _storage._defaultValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._defaultValue, fieldNumber: 228)
-      }
-      if _storage._dependency != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._dependency, fieldNumber: 229)
-      }
-      if _storage._deprecated != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._deprecated, fieldNumber: 230)
-      }
-      if _storage._deprecatedLegacyJsonFieldConflicts != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._deprecatedLegacyJsonFieldConflicts, fieldNumber: 231)
-      }
-      if _storage._description_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._description_p, fieldNumber: 232)
-      }
-      if _storage._descriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._descriptorProto, fieldNumber: 233)
-      }
-      if _storage._dictionary != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._dictionary, fieldNumber: 234)
-      }
-      if _storage._dictionaryLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._dictionaryLiteral, fieldNumber: 235)
-      }
-      if _storage._digit != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._digit, fieldNumber: 236)
-      }
-      if _storage._digit0 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._digit0, fieldNumber: 237)
-      }
-      if _storage._digit1 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._digit1, fieldNumber: 238)
-      }
-      if _storage._digitCount != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._digitCount, fieldNumber: 239)
-      }
-      if _storage._digits != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._digits, fieldNumber: 240)
-      }
-      if _storage._digitValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._digitValue, fieldNumber: 241)
-      }
-      if _storage._discardableResult != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._discardableResult, fieldNumber: 242)
-      }
-      if _storage._discardUnknownFields != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._discardUnknownFields, fieldNumber: 243)
-      }
-      if _storage._double != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._double, fieldNumber: 244)
-      }
-      if _storage._doubleValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._doubleValue, fieldNumber: 245)
-      }
-      if _storage._duration != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._duration, fieldNumber: 246)
-      }
-      if _storage._e != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._e, fieldNumber: 247)
-      }
-      if _storage._edition != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._edition, fieldNumber: 248)
-      }
-      if _storage._editionDefault != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._editionDefault, fieldNumber: 249)
-      }
-      if _storage._editionDefaults != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._editionDefaults, fieldNumber: 250)
-      }
-      if _storage._element != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._element, fieldNumber: 251)
-      }
-      if _storage._elements != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._elements, fieldNumber: 252)
-      }
-      if _storage._emitExtensionFieldName != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._emitExtensionFieldName, fieldNumber: 253)
-      }
-      if _storage._emitFieldName != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._emitFieldName, fieldNumber: 254)
-      }
-      if _storage._emitFieldNumber != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._emitFieldNumber, fieldNumber: 255)
-      }
-      if _storage._empty != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._empty, fieldNumber: 256)
-      }
-      if _storage._encodeAsBytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._encodeAsBytes, fieldNumber: 257)
-      }
-      if _storage._encoded != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._encoded, fieldNumber: 258)
-      }
-      if _storage._encodedJsonstring != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._encodedJsonstring, fieldNumber: 259)
-      }
-      if _storage._encodedSize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._encodedSize, fieldNumber: 260)
-      }
-      if _storage._encodeField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._encodeField, fieldNumber: 261)
-      }
-      if _storage._encoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._encoder, fieldNumber: 262)
-      }
-      if _storage._end != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._end, fieldNumber: 263)
-      }
-      if _storage._endArray != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._endArray, fieldNumber: 264)
-      }
-      if _storage._endMessageField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._endMessageField, fieldNumber: 265)
-      }
-      if _storage._endObject != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._endObject, fieldNumber: 266)
-      }
-      if _storage._endRegularField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._endRegularField, fieldNumber: 267)
-      }
-      if _storage._enum != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._enum, fieldNumber: 268)
-      }
-      if _storage._enumDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._enumDescriptorProto, fieldNumber: 269)
-      }
-      if _storage._enumOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._enumOptions, fieldNumber: 270)
-      }
-      if _storage._enumReservedRange != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._enumReservedRange, fieldNumber: 271)
-      }
-      if _storage._enumType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._enumType, fieldNumber: 272)
-      }
-      if _storage._enumvalue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._enumvalue, fieldNumber: 273)
-      }
-      if _storage._enumValueDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._enumValueDescriptorProto, fieldNumber: 274)
-      }
-      if _storage._enumValueOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._enumValueOptions, fieldNumber: 275)
-      }
-      if _storage._equatable != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._equatable, fieldNumber: 276)
-      }
-      if _storage._error != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._error, fieldNumber: 277)
-      }
-      if _storage._expressibleByArrayLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._expressibleByArrayLiteral, fieldNumber: 278)
-      }
-      if _storage._expressibleByDictionaryLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._expressibleByDictionaryLiteral, fieldNumber: 279)
-      }
-      if _storage._ext != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._ext, fieldNumber: 280)
-      }
-      if _storage._extDecoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extDecoder, fieldNumber: 281)
-      }
-      if _storage._extendedGraphemeClusterLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extendedGraphemeClusterLiteral, fieldNumber: 282)
-      }
-      if _storage._extendedGraphemeClusterLiteralType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extendedGraphemeClusterLiteralType, fieldNumber: 283)
-      }
-      if _storage._extendee != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extendee, fieldNumber: 284)
-      }
-      if _storage._extensibleMessage != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extensibleMessage, fieldNumber: 285)
-      }
-      if _storage._extension != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extension, fieldNumber: 286)
-      }
-      if _storage._extensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extensionField, fieldNumber: 287)
-      }
-      if _storage._extensionFieldNumber != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extensionFieldNumber, fieldNumber: 288)
-      }
-      if _storage._extensionFieldValueSet != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extensionFieldValueSet, fieldNumber: 289)
-      }
-      if _storage._extensionMap != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extensionMap, fieldNumber: 290)
-      }
-      if _storage._extensionRange != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extensionRange, fieldNumber: 291)
-      }
-      if _storage._extensionRangeOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extensionRangeOptions, fieldNumber: 292)
-      }
-      if _storage._extensions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extensions, fieldNumber: 293)
-      }
-      if _storage._extras != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._extras, fieldNumber: 294)
-      }
-      if _storage._f != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._f, fieldNumber: 295)
-      }
-      if _storage._false != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._false, fieldNumber: 296)
-      }
-      if _storage._features != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._features, fieldNumber: 297)
-      }
-      if _storage._featureSet != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._featureSet, fieldNumber: 298)
-      }
-      if _storage._featureSetDefaults != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._featureSetDefaults, fieldNumber: 299)
-      }
-      if _storage._featureSetEditionDefault != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._featureSetEditionDefault, fieldNumber: 300)
-      }
-      if _storage._field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field, fieldNumber: 301)
-      }
-      if _storage._fieldData != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldData, fieldNumber: 302)
-      }
-      if _storage._fieldDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldDescriptorProto, fieldNumber: 303)
-      }
-      if _storage._fieldMask != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldMask, fieldNumber: 304)
-      }
-      if _storage._fieldName != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName, fieldNumber: 305)
-      }
-      if _storage._fieldNameCount != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldNameCount, fieldNumber: 306)
-      }
-      if _storage._fieldNum != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldNum, fieldNumber: 307)
-      }
-      if _storage._fieldNumber != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldNumber, fieldNumber: 308)
-      }
-      if _storage._fieldNumberForProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldNumberForProto, fieldNumber: 309)
-      }
-      if _storage._fieldOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldOptions, fieldNumber: 310)
-      }
-      if _storage._fieldPresence != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldPresence, fieldNumber: 311)
-      }
-      if _storage._fields != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fields, fieldNumber: 312)
-      }
-      if _storage._fieldSize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldSize, fieldNumber: 313)
-      }
-      if _storage._fieldTag != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldTag, fieldNumber: 314)
-      }
-      if _storage._fieldType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldType, fieldNumber: 315)
-      }
-      if _storage._file != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._file, fieldNumber: 316)
-      }
-      if _storage._fileDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fileDescriptorProto, fieldNumber: 317)
-      }
-      if _storage._fileDescriptorSet != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fileDescriptorSet, fieldNumber: 318)
-      }
-      if _storage._fileName != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fileName, fieldNumber: 319)
-      }
-      if _storage._fileOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fileOptions, fieldNumber: 320)
-      }
-      if _storage._filter != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._filter, fieldNumber: 321)
-      }
-      if _storage._final != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._final, fieldNumber: 322)
-      }
-      if _storage._first != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._first, fieldNumber: 323)
-      }
-      if _storage._firstItem != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._firstItem, fieldNumber: 324)
-      }
-      if _storage._float != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._float, fieldNumber: 325)
-      }
-      if _storage._floatLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._floatLiteral, fieldNumber: 326)
-      }
-      if _storage._floatLiteralType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._floatLiteralType, fieldNumber: 327)
-      }
-      if _storage._floatValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._floatValue, fieldNumber: 328)
-      }
-      if _storage._forMessageName != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._forMessageName, fieldNumber: 329)
-      }
-      if _storage._formUnion != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._formUnion, fieldNumber: 330)
-      }
-      if _storage._forReadingFrom != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._forReadingFrom, fieldNumber: 331)
-      }
-      if _storage._forTypeURL != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._forTypeURL, fieldNumber: 332)
-      }
-      if _storage._forwardParser != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._forwardParser, fieldNumber: 333)
-      }
-      if _storage._forWritingInto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._forWritingInto, fieldNumber: 334)
-      }
-      if _storage._from != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._from, fieldNumber: 335)
-      }
-      if _storage._fromAscii2 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fromAscii2, fieldNumber: 336)
-      }
-      if _storage._fromAscii4 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fromAscii4, fieldNumber: 337)
-      }
-      if _storage._fromByteOffset != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fromByteOffset, fieldNumber: 338)
-      }
-      if _storage._fromHexDigit != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fromHexDigit, fieldNumber: 339)
-      }
-      if _storage._fullName != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fullName, fieldNumber: 340)
-      }
-      if _storage._func != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._func, fieldNumber: 341)
-      }
-      if _storage._g != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._g, fieldNumber: 342)
-      }
-      if _storage._generatedCodeInfo != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._generatedCodeInfo, fieldNumber: 343)
-      }
-      if _storage._get != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._get, fieldNumber: 344)
-      }
-      if _storage._getExtensionValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._getExtensionValue, fieldNumber: 345)
-      }
-      if _storage._googleapis != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleapis, fieldNumber: 346)
-      }
-      if _storage._googleProtobufAny != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufAny, fieldNumber: 347)
-      }
-      if _storage._googleProtobufApi != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufApi, fieldNumber: 348)
-      }
-      if _storage._googleProtobufBoolValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufBoolValue, fieldNumber: 349)
-      }
-      if _storage._googleProtobufBytesValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufBytesValue, fieldNumber: 350)
-      }
-      if _storage._googleProtobufDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufDescriptorProto, fieldNumber: 351)
-      }
-      if _storage._googleProtobufDoubleValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufDoubleValue, fieldNumber: 352)
-      }
-      if _storage._googleProtobufDuration != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufDuration, fieldNumber: 353)
-      }
-      if _storage._googleProtobufEdition != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufEdition, fieldNumber: 354)
-      }
-      if _storage._googleProtobufEmpty != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufEmpty, fieldNumber: 355)
-      }
-      if _storage._googleProtobufEnum != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnum, fieldNumber: 356)
-      }
-      if _storage._googleProtobufEnumDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumDescriptorProto, fieldNumber: 357)
-      }
-      if _storage._googleProtobufEnumOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumOptions, fieldNumber: 358)
-      }
-      if _storage._googleProtobufEnumValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValue, fieldNumber: 359)
-      }
-      if _storage._googleProtobufEnumValueDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValueDescriptorProto, fieldNumber: 360)
-      }
-      if _storage._googleProtobufEnumValueOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValueOptions, fieldNumber: 361)
-      }
-      if _storage._googleProtobufExtensionRangeOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufExtensionRangeOptions, fieldNumber: 362)
-      }
-      if _storage._googleProtobufFeatureSet != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufFeatureSet, fieldNumber: 363)
-      }
-      if _storage._googleProtobufFeatureSetDefaults != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufFeatureSetDefaults, fieldNumber: 364)
-      }
-      if _storage._googleProtobufField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufField, fieldNumber: 365)
-      }
-      if _storage._googleProtobufFieldDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldDescriptorProto, fieldNumber: 366)
-      }
-      if _storage._googleProtobufFieldMask != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldMask, fieldNumber: 367)
-      }
-      if _storage._googleProtobufFieldOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldOptions, fieldNumber: 368)
-      }
-      if _storage._googleProtobufFileDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileDescriptorProto, fieldNumber: 369)
-      }
-      if _storage._googleProtobufFileDescriptorSet != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileDescriptorSet, fieldNumber: 370)
-      }
-      if _storage._googleProtobufFileOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileOptions, fieldNumber: 371)
-      }
-      if _storage._googleProtobufFloatValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufFloatValue, fieldNumber: 372)
-      }
-      if _storage._googleProtobufGeneratedCodeInfo != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufGeneratedCodeInfo, fieldNumber: 373)
-      }
-      if _storage._googleProtobufInt32Value != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufInt32Value, fieldNumber: 374)
-      }
-      if _storage._googleProtobufInt64Value != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufInt64Value, fieldNumber: 375)
-      }
-      if _storage._googleProtobufListValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufListValue, fieldNumber: 376)
-      }
-      if _storage._googleProtobufMessageOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufMessageOptions, fieldNumber: 377)
-      }
-      if _storage._googleProtobufMethod != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethod, fieldNumber: 378)
-      }
-      if _storage._googleProtobufMethodDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethodDescriptorProto, fieldNumber: 379)
-      }
-      if _storage._googleProtobufMethodOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethodOptions, fieldNumber: 380)
-      }
-      if _storage._googleProtobufMixin != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufMixin, fieldNumber: 381)
-      }
-      if _storage._googleProtobufNullValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufNullValue, fieldNumber: 382)
-      }
-      if _storage._googleProtobufOneofDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufOneofDescriptorProto, fieldNumber: 383)
-      }
-      if _storage._googleProtobufOneofOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufOneofOptions, fieldNumber: 384)
-      }
-      if _storage._googleProtobufOption != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufOption, fieldNumber: 385)
-      }
-      if _storage._googleProtobufServiceDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufServiceDescriptorProto, fieldNumber: 386)
-      }
-      if _storage._googleProtobufServiceOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufServiceOptions, fieldNumber: 387)
-      }
-      if _storage._googleProtobufSourceCodeInfo != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufSourceCodeInfo, fieldNumber: 388)
-      }
-      if _storage._googleProtobufSourceContext != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufSourceContext, fieldNumber: 389)
-      }
-      if _storage._googleProtobufStringValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufStringValue, fieldNumber: 390)
-      }
-      if _storage._googleProtobufStruct != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufStruct, fieldNumber: 391)
-      }
-      if _storage._googleProtobufSyntax != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufSyntax, fieldNumber: 392)
-      }
-      if _storage._googleProtobufTimestamp != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufTimestamp, fieldNumber: 393)
-      }
-      if _storage._googleProtobufType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufType, fieldNumber: 394)
-      }
-      if _storage._googleProtobufUint32Value != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufUint32Value, fieldNumber: 395)
-      }
-      if _storage._googleProtobufUint64Value != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufUint64Value, fieldNumber: 396)
-      }
-      if _storage._googleProtobufUninterpretedOption != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufUninterpretedOption, fieldNumber: 397)
-      }
-      if _storage._googleProtobufValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._googleProtobufValue, fieldNumber: 398)
-      }
-      if _storage._goPackage != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._goPackage, fieldNumber: 399)
-      }
-      if _storage._group != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._group, fieldNumber: 400)
-      }
-      if _storage._groupFieldNumberStack != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._groupFieldNumberStack, fieldNumber: 401)
-      }
-      if _storage._groupSize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._groupSize, fieldNumber: 402)
-      }
-      if _storage._hadOneofValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hadOneofValue, fieldNumber: 403)
-      }
-      if _storage._handleConflictingOneOf != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._handleConflictingOneOf, fieldNumber: 404)
-      }
-      if _storage._hasAggregateValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasAggregateValue_p, fieldNumber: 405)
-      }
-      if _storage._hasAllowAlias_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasAllowAlias_p, fieldNumber: 406)
-      }
-      if _storage._hasBegin_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasBegin_p, fieldNumber: 407)
-      }
-      if _storage._hasCcEnableArenas_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasCcEnableArenas_p, fieldNumber: 408)
-      }
-      if _storage._hasCcGenericServices_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasCcGenericServices_p, fieldNumber: 409)
-      }
-      if _storage._hasClientStreaming_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasClientStreaming_p, fieldNumber: 410)
-      }
-      if _storage._hasCsharpNamespace_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasCsharpNamespace_p, fieldNumber: 411)
-      }
-      if _storage._hasCtype_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasCtype_p, fieldNumber: 412)
-      }
-      if _storage._hasDebugRedact_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasDebugRedact_p, fieldNumber: 413)
-      }
-      if _storage._hasDefaultValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasDefaultValue_p, fieldNumber: 414)
-      }
-      if _storage._hasDeprecated_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasDeprecated_p, fieldNumber: 415)
-      }
-      if _storage._hasDeprecatedLegacyJsonFieldConflicts_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 416)
-      }
-      if _storage._hasDoubleValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasDoubleValue_p, fieldNumber: 417)
-      }
-      if _storage._hasEdition_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasEdition_p, fieldNumber: 418)
-      }
-      if _storage._hasEnd_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasEnd_p, fieldNumber: 419)
-      }
-      if _storage._hasEnumType_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasEnumType_p, fieldNumber: 420)
-      }
-      if _storage._hasExtendee_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasExtendee_p, fieldNumber: 421)
-      }
-      if _storage._hasExtensionValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasExtensionValue_p, fieldNumber: 422)
-      }
-      if _storage._hasFeatures_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasFeatures_p, fieldNumber: 423)
-      }
-      if _storage._hasFieldPresence_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasFieldPresence_p, fieldNumber: 424)
-      }
-      if _storage._hasFullName_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasFullName_p, fieldNumber: 425)
-      }
-      if _storage._hasGoPackage_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasGoPackage_p, fieldNumber: 426)
-      }
-      if _storage._hash != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hash, fieldNumber: 427)
-      }
-      if _storage._hashable != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hashable, fieldNumber: 428)
-      }
-      if _storage._hasher != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasher, fieldNumber: 429)
-      }
-      if _storage._hashVisitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hashVisitor, fieldNumber: 430)
-      }
-      if _storage._hasIdempotencyLevel_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasIdempotencyLevel_p, fieldNumber: 431)
-      }
-      if _storage._hasIdentifierValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasIdentifierValue_p, fieldNumber: 432)
-      }
-      if _storage._hasInputType_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasInputType_p, fieldNumber: 433)
-      }
-      if _storage._hasIsExtension_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasIsExtension_p, fieldNumber: 434)
-      }
-      if _storage._hasJavaGenerateEqualsAndHash_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasJavaGenerateEqualsAndHash_p, fieldNumber: 435)
-      }
-      if _storage._hasJavaGenericServices_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasJavaGenericServices_p, fieldNumber: 436)
-      }
-      if _storage._hasJavaMultipleFiles_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasJavaMultipleFiles_p, fieldNumber: 437)
-      }
-      if _storage._hasJavaOuterClassname_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasJavaOuterClassname_p, fieldNumber: 438)
-      }
-      if _storage._hasJavaPackage_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasJavaPackage_p, fieldNumber: 439)
-      }
-      if _storage._hasJavaStringCheckUtf8_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasJavaStringCheckUtf8_p, fieldNumber: 440)
-      }
-      if _storage._hasJsonFormat_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasJsonFormat_p, fieldNumber: 441)
-      }
-      if _storage._hasJsonName_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasJsonName_p, fieldNumber: 442)
-      }
-      if _storage._hasJstype_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasJstype_p, fieldNumber: 443)
-      }
-      if _storage._hasLabel_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasLabel_p, fieldNumber: 444)
-      }
-      if _storage._hasLazy_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasLazy_p, fieldNumber: 445)
-      }
-      if _storage._hasLeadingComments_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasLeadingComments_p, fieldNumber: 446)
-      }
-      if _storage._hasMapEntry_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasMapEntry_p, fieldNumber: 447)
-      }
-      if _storage._hasMaximumEdition_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasMaximumEdition_p, fieldNumber: 448)
-      }
-      if _storage._hasMessageEncoding_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasMessageEncoding_p, fieldNumber: 449)
-      }
-      if _storage._hasMessageSetWireFormat_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasMessageSetWireFormat_p, fieldNumber: 450)
-      }
-      if _storage._hasMinimumEdition_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasMinimumEdition_p, fieldNumber: 451)
-      }
-      if _storage._hasName_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasName_p, fieldNumber: 452)
-      }
-      if _storage._hasNamePart_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasNamePart_p, fieldNumber: 453)
-      }
-      if _storage._hasNegativeIntValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasNegativeIntValue_p, fieldNumber: 454)
-      }
-      if _storage._hasNoStandardDescriptorAccessor_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasNoStandardDescriptorAccessor_p, fieldNumber: 455)
-      }
-      if _storage._hasNumber_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasNumber_p, fieldNumber: 456)
-      }
-      if _storage._hasObjcClassPrefix_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasObjcClassPrefix_p, fieldNumber: 457)
-      }
-      if _storage._hasOneofIndex_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasOneofIndex_p, fieldNumber: 458)
-      }
-      if _storage._hasOptimizeFor_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasOptimizeFor_p, fieldNumber: 459)
-      }
-      if _storage._hasOptions_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasOptions_p, fieldNumber: 460)
-      }
-      if _storage._hasOutputType_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasOutputType_p, fieldNumber: 461)
-      }
-      if _storage._hasPackage_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasPackage_p, fieldNumber: 462)
-      }
-      if _storage._hasPacked_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasPacked_p, fieldNumber: 463)
-      }
-      if _storage._hasPhpClassPrefix_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasPhpClassPrefix_p, fieldNumber: 464)
-      }
-      if _storage._hasPhpGenericServices_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasPhpGenericServices_p, fieldNumber: 465)
-      }
-      if _storage._hasPhpMetadataNamespace_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasPhpMetadataNamespace_p, fieldNumber: 466)
-      }
-      if _storage._hasPhpNamespace_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasPhpNamespace_p, fieldNumber: 467)
-      }
-      if _storage._hasPositiveIntValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasPositiveIntValue_p, fieldNumber: 468)
-      }
-      if _storage._hasProto3Optional_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasProto3Optional_p, fieldNumber: 469)
-      }
-      if _storage._hasPyGenericServices_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasPyGenericServices_p, fieldNumber: 470)
-      }
-      if _storage._hasRepeated_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasRepeated_p, fieldNumber: 471)
-      }
-      if _storage._hasRepeatedFieldEncoding_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasRepeatedFieldEncoding_p, fieldNumber: 472)
-      }
-      if _storage._hasReserved_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasReserved_p, fieldNumber: 473)
-      }
-      if _storage._hasRetention_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasRetention_p, fieldNumber: 474)
-      }
-      if _storage._hasRubyPackage_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasRubyPackage_p, fieldNumber: 475)
-      }
-      if _storage._hasSemantic_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasSemantic_p, fieldNumber: 476)
-      }
-      if _storage._hasServerStreaming_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasServerStreaming_p, fieldNumber: 477)
-      }
-      if _storage._hasSourceCodeInfo_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasSourceCodeInfo_p, fieldNumber: 478)
-      }
-      if _storage._hasSourceContext_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasSourceContext_p, fieldNumber: 479)
-      }
-      if _storage._hasSourceFile_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasSourceFile_p, fieldNumber: 480)
-      }
-      if _storage._hasStart_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasStart_p, fieldNumber: 481)
-      }
-      if _storage._hasStringValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasStringValue_p, fieldNumber: 482)
-      }
-      if _storage._hasSwiftPrefix_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasSwiftPrefix_p, fieldNumber: 483)
-      }
-      if _storage._hasSyntax_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasSyntax_p, fieldNumber: 484)
-      }
-      if _storage._hasTrailingComments_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasTrailingComments_p, fieldNumber: 485)
-      }
-      if _storage._hasType_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasType_p, fieldNumber: 486)
-      }
-      if _storage._hasTypeName_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasTypeName_p, fieldNumber: 487)
-      }
-      if _storage._hasUnverifiedLazy_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasUnverifiedLazy_p, fieldNumber: 488)
-      }
-      if _storage._hasUtf8Validation_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasUtf8Validation_p, fieldNumber: 489)
-      }
-      if _storage._hasValue_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasValue_p, fieldNumber: 490)
-      }
-      if _storage._hasVerification_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasVerification_p, fieldNumber: 491)
-      }
-      if _storage._hasWeak_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hasWeak_p, fieldNumber: 492)
-      }
-      if _storage._hour != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._hour, fieldNumber: 493)
-      }
-      if _storage._i != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._i, fieldNumber: 494)
-      }
-      if _storage._idempotencyLevel != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._idempotencyLevel, fieldNumber: 495)
-      }
-      if _storage._identifierValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._identifierValue, fieldNumber: 496)
-      }
-      if _storage._if != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._if, fieldNumber: 497)
-      }
-      if _storage._ignoreUnknownFields != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._ignoreUnknownFields, fieldNumber: 498)
-      }
-      if _storage._index != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._index, fieldNumber: 499)
-      }
-      if _storage._init_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._init_p, fieldNumber: 500)
-      }
-      if _storage._inout != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._inout, fieldNumber: 501)
-      }
-      if _storage._inputType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._inputType, fieldNumber: 502)
-      }
-      if _storage._insert != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._insert, fieldNumber: 503)
-      }
-      if _storage._int != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._int, fieldNumber: 504)
-      }
-      if _storage._int32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._int32, fieldNumber: 505)
-      }
-      if _storage._int32Value != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._int32Value, fieldNumber: 506)
-      }
-      if _storage._int64 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._int64, fieldNumber: 507)
-      }
-      if _storage._int64Value != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._int64Value, fieldNumber: 508)
-      }
-      if _storage._int8 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._int8, fieldNumber: 509)
-      }
-      if _storage._integerLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._integerLiteral, fieldNumber: 510)
-      }
-      if _storage._integerLiteralType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._integerLiteralType, fieldNumber: 511)
-      }
-      if _storage._intern != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._intern, fieldNumber: 512)
-      }
-      if _storage._internal != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._internal, fieldNumber: 513)
-      }
-      if _storage._internalState != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._internalState, fieldNumber: 514)
-      }
-      if _storage._into != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._into, fieldNumber: 515)
-      }
-      if _storage._ints != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._ints, fieldNumber: 516)
-      }
-      if _storage._isA != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._isA, fieldNumber: 517)
-      }
-      if _storage._isEqual != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._isEqual, fieldNumber: 518)
-      }
-      if _storage._isEqualTo != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._isEqualTo, fieldNumber: 519)
-      }
-      if _storage._isExtension != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._isExtension, fieldNumber: 520)
-      }
-      if _storage._isInitialized_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._isInitialized_p, fieldNumber: 521)
-      }
-      if _storage._isNegative != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._isNegative, fieldNumber: 522)
-      }
-      if _storage._itemTagsEncodedSize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._itemTagsEncodedSize, fieldNumber: 523)
-      }
-      if _storage._iterator != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._iterator, fieldNumber: 524)
-      }
-      if _storage._javaGenerateEqualsAndHash != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._javaGenerateEqualsAndHash, fieldNumber: 525)
-      }
-      if _storage._javaGenericServices != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._javaGenericServices, fieldNumber: 526)
-      }
-      if _storage._javaMultipleFiles != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._javaMultipleFiles, fieldNumber: 527)
-      }
-      if _storage._javaOuterClassname != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._javaOuterClassname, fieldNumber: 528)
-      }
-      if _storage._javaPackage != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._javaPackage, fieldNumber: 529)
-      }
-      if _storage._javaStringCheckUtf8 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._javaStringCheckUtf8, fieldNumber: 530)
-      }
-      if _storage._jsondecoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsondecoder, fieldNumber: 531)
-      }
-      if _storage._jsondecodingError != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsondecodingError, fieldNumber: 532)
-      }
-      if _storage._jsondecodingOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsondecodingOptions, fieldNumber: 533)
-      }
-      if _storage._jsonEncoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonEncoder, fieldNumber: 534)
-      }
-      if _storage._jsonencodingError != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonencodingError, fieldNumber: 535)
-      }
-      if _storage._jsonencodingOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonencodingOptions, fieldNumber: 536)
-      }
-      if _storage._jsonencodingVisitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonencodingVisitor, fieldNumber: 537)
-      }
-      if _storage._jsonFormat != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonFormat, fieldNumber: 538)
-      }
-      if _storage._jsonmapEncodingVisitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonmapEncodingVisitor, fieldNumber: 539)
-      }
-      if _storage._jsonName != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonName, fieldNumber: 540)
-      }
-      if _storage._jsonPath != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonPath, fieldNumber: 541)
-      }
-      if _storage._jsonPaths != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonPaths, fieldNumber: 542)
-      }
-      if _storage._jsonscanner != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonscanner, fieldNumber: 543)
-      }
-      if _storage._jsonString != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonString, fieldNumber: 544)
-      }
-      if _storage._jsonText != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonText, fieldNumber: 545)
-      }
-      if _storage._jsonUtf8Bytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonUtf8Bytes, fieldNumber: 546)
-      }
-      if _storage._jsonUtf8Data != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jsonUtf8Data, fieldNumber: 547)
-      }
-      if _storage._jstype != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._jstype, fieldNumber: 548)
-      }
-      if _storage._k != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._k, fieldNumber: 549)
-      }
-      if _storage._kChunkSize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._kChunkSize, fieldNumber: 550)
-      }
-      if _storage._key != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._key, fieldNumber: 551)
-      }
-      if _storage._keyField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._keyField, fieldNumber: 552)
-      }
-      if _storage._keyFieldOpt != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._keyFieldOpt, fieldNumber: 553)
-      }
-      if _storage._keyType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._keyType, fieldNumber: 554)
-      }
-      if _storage._kind != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._kind, fieldNumber: 555)
-      }
-      if _storage._l != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._l, fieldNumber: 556)
-      }
-      if _storage._label != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._label, fieldNumber: 557)
-      }
-      if _storage._lazy != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._lazy, fieldNumber: 558)
-      }
-      if _storage._leadingComments != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._leadingComments, fieldNumber: 559)
-      }
-      if _storage._leadingDetachedComments != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._leadingDetachedComments, fieldNumber: 560)
-      }
-      if _storage._length != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._length, fieldNumber: 561)
-      }
-      if _storage._lessThan != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._lessThan, fieldNumber: 562)
-      }
-      if _storage._let != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._let, fieldNumber: 563)
-      }
-      if _storage._lhs != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._lhs, fieldNumber: 564)
-      }
-      if _storage._list != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._list, fieldNumber: 565)
-      }
-      if _storage._listOfMessages != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._listOfMessages, fieldNumber: 566)
-      }
-      if _storage._listValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._listValue, fieldNumber: 567)
-      }
-      if _storage._littleEndian != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._littleEndian, fieldNumber: 568)
-      }
-      if _storage._littleEndianBytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._littleEndianBytes, fieldNumber: 569)
-      }
-      if _storage._load != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._load, fieldNumber: 570)
-      }
-      if _storage._localHasher != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._localHasher, fieldNumber: 571)
-      }
-      if _storage._location != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._location, fieldNumber: 572)
-      }
-      if _storage._m != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._m, fieldNumber: 573)
-      }
-      if _storage._major != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._major, fieldNumber: 574)
-      }
-      if _storage._makeAsyncIterator != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._makeAsyncIterator, fieldNumber: 575)
-      }
-      if _storage._makeIterator != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._makeIterator, fieldNumber: 576)
-      }
-      if _storage._mapEntry != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._mapEntry, fieldNumber: 577)
-      }
-      if _storage._mapKeyType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._mapKeyType, fieldNumber: 578)
-      }
-      if _storage._mapToMessages != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._mapToMessages, fieldNumber: 579)
-      }
-      if _storage._mapValueType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._mapValueType, fieldNumber: 580)
-      }
-      if _storage._mapVisitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._mapVisitor, fieldNumber: 581)
-      }
-      if _storage._maximumEdition != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._maximumEdition, fieldNumber: 582)
-      }
-      if _storage._mdayStart != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._mdayStart, fieldNumber: 583)
-      }
-      if _storage._merge != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._merge, fieldNumber: 584)
-      }
-      if _storage._message != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._message, fieldNumber: 585)
-      }
-      if _storage._messageDepthLimit != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._messageDepthLimit, fieldNumber: 586)
-      }
-      if _storage._messageEncoding != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._messageEncoding, fieldNumber: 587)
-      }
-      if _storage._messageExtension != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._messageExtension, fieldNumber: 588)
-      }
-      if _storage._messageImplementationBase != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._messageImplementationBase, fieldNumber: 589)
-      }
-      if _storage._messageOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._messageOptions, fieldNumber: 590)
-      }
-      if _storage._messageSet != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._messageSet, fieldNumber: 591)
-      }
-      if _storage._messageSetWireFormat != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._messageSetWireFormat, fieldNumber: 592)
-      }
-      if _storage._messageSize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._messageSize, fieldNumber: 593)
-      }
-      if _storage._messageType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._messageType, fieldNumber: 594)
-      }
-      if _storage._method != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._method, fieldNumber: 595)
-      }
-      if _storage._methodDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._methodDescriptorProto, fieldNumber: 596)
-      }
-      if _storage._methodOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._methodOptions, fieldNumber: 597)
-      }
-      if _storage._methods != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._methods, fieldNumber: 598)
-      }
-      if _storage._min != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._min, fieldNumber: 599)
-      }
-      if _storage._minimumEdition != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._minimumEdition, fieldNumber: 600)
-      }
-      if _storage._minor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._minor, fieldNumber: 601)
-      }
-      if _storage._mixin != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._mixin, fieldNumber: 602)
-      }
-      if _storage._mixins != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._mixins, fieldNumber: 603)
-      }
-      if _storage._modifier != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._modifier, fieldNumber: 604)
-      }
-      if _storage._modify != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._modify, fieldNumber: 605)
-      }
-      if _storage._month != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._month, fieldNumber: 606)
-      }
-      if _storage._msgExtension != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._msgExtension, fieldNumber: 607)
-      }
-      if _storage._mutating != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._mutating, fieldNumber: 608)
-      }
-      if _storage._n != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._n, fieldNumber: 609)
-      }
-      if _storage._name != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._name, fieldNumber: 610)
-      }
-      if _storage._nameDescription != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._nameDescription, fieldNumber: 611)
-      }
-      if _storage._nameMap != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._nameMap, fieldNumber: 612)
-      }
-      if _storage._namePart != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._namePart, fieldNumber: 613)
-      }
-      if _storage._names != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._names, fieldNumber: 614)
-      }
-      if _storage._nanos != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._nanos, fieldNumber: 615)
-      }
-      if _storage._negativeIntValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._negativeIntValue, fieldNumber: 616)
-      }
-      if _storage._nestedType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._nestedType, fieldNumber: 617)
-      }
-      if _storage._newL != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._newL, fieldNumber: 618)
-      }
-      if _storage._newList != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._newList, fieldNumber: 619)
-      }
-      if _storage._newValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._newValue, fieldNumber: 620)
-      }
-      if _storage._next != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._next, fieldNumber: 621)
-      }
-      if _storage._nextByte != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._nextByte, fieldNumber: 622)
-      }
-      if _storage._nextFieldNumber != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._nextFieldNumber, fieldNumber: 623)
-      }
-      if _storage._nextVarInt != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._nextVarInt, fieldNumber: 624)
-      }
-      if _storage._nil != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._nil, fieldNumber: 625)
-      }
-      if _storage._nilLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._nilLiteral, fieldNumber: 626)
-      }
-      if _storage._noStandardDescriptorAccessor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._noStandardDescriptorAccessor, fieldNumber: 627)
-      }
-      if _storage._nullValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._nullValue, fieldNumber: 628)
-      }
-      if _storage._number != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._number, fieldNumber: 629)
-      }
-      if _storage._numberValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._numberValue, fieldNumber: 630)
-      }
-      if _storage._objcClassPrefix != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._objcClassPrefix, fieldNumber: 631)
-      }
-      if _storage._of != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._of, fieldNumber: 632)
-      }
-      if _storage._oneofDecl != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._oneofDecl, fieldNumber: 633)
-      }
-      if _storage._oneofDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._oneofDescriptorProto, fieldNumber: 634)
-      }
-      if _storage._oneofIndex != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._oneofIndex, fieldNumber: 635)
-      }
-      if _storage._oneofOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._oneofOptions, fieldNumber: 636)
-      }
-      if _storage._oneofs != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._oneofs, fieldNumber: 637)
-      }
-      if _storage._oneOfKind != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._oneOfKind, fieldNumber: 638)
-      }
-      if _storage._optimizeFor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optimizeFor, fieldNumber: 639)
-      }
-      if _storage._optimizeMode != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optimizeMode, fieldNumber: 640)
-      }
-      if _storage._option != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._option, fieldNumber: 641)
-      }
-      if _storage._optionalEnumExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optionalEnumExtensionField, fieldNumber: 642)
-      }
-      if _storage._optionalExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optionalExtensionField, fieldNumber: 643)
-      }
-      if _storage._optionalGroupExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optionalGroupExtensionField, fieldNumber: 644)
-      }
-      if _storage._optionalMessageExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optionalMessageExtensionField, fieldNumber: 645)
-      }
-      if _storage._optionRetention != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optionRetention, fieldNumber: 646)
-      }
-      if _storage._options != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._options, fieldNumber: 647)
-      }
-      if _storage._optionTargetType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optionTargetType, fieldNumber: 648)
-      }
-      if _storage._other != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._other, fieldNumber: 649)
-      }
-      if _storage._others != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._others, fieldNumber: 650)
-      }
-      if _storage._out != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._out, fieldNumber: 651)
-      }
-      if _storage._outputType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._outputType, fieldNumber: 652)
-      }
-      if _storage._p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._p, fieldNumber: 653)
-      }
-      if _storage._package != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._package, fieldNumber: 654)
-      }
-      if _storage._packed != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._packed, fieldNumber: 655)
-      }
-      if _storage._packedEnumExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._packedEnumExtensionField, fieldNumber: 656)
-      }
-      if _storage._packedExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._packedExtensionField, fieldNumber: 657)
-      }
-      if _storage._padding != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._padding, fieldNumber: 658)
-      }
-      if _storage._parent != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._parent, fieldNumber: 659)
-      }
-      if _storage._parse != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._parse, fieldNumber: 660)
-      }
-      if _storage._path != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._path, fieldNumber: 661)
-      }
-      if _storage._paths != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._paths, fieldNumber: 662)
-      }
-      if _storage._payload != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._payload, fieldNumber: 663)
-      }
-      if _storage._payloadSize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._payloadSize, fieldNumber: 664)
-      }
-      if _storage._phpClassPrefix != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._phpClassPrefix, fieldNumber: 665)
-      }
-      if _storage._phpGenericServices != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._phpGenericServices, fieldNumber: 666)
-      }
-      if _storage._phpMetadataNamespace != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._phpMetadataNamespace, fieldNumber: 667)
-      }
-      if _storage._phpNamespace != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._phpNamespace, fieldNumber: 668)
-      }
-      if _storage._pos != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._pos, fieldNumber: 669)
-      }
-      if _storage._positiveIntValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._positiveIntValue, fieldNumber: 670)
-      }
-      if _storage._prefix != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._prefix, fieldNumber: 671)
-      }
-      if _storage._preserveProtoFieldNames != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._preserveProtoFieldNames, fieldNumber: 672)
-      }
-      if _storage._preTraverse != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._preTraverse, fieldNumber: 673)
-      }
-      if _storage._printUnknownFields != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._printUnknownFields, fieldNumber: 674)
-      }
-      if _storage._proto2 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._proto2, fieldNumber: 675)
-      }
-      if _storage._proto3DefaultValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._proto3DefaultValue, fieldNumber: 676)
-      }
-      if _storage._proto3Optional != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._proto3Optional, fieldNumber: 677)
-      }
-      if _storage._protobufApiversionCheck != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufApiversionCheck, fieldNumber: 678)
-      }
-      if _storage._protobufApiversion3 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufApiversion3, fieldNumber: 679)
-      }
-      if _storage._protobufBool != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufBool, fieldNumber: 680)
-      }
-      if _storage._protobufBytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufBytes, fieldNumber: 681)
-      }
-      if _storage._protobufDouble != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufDouble, fieldNumber: 682)
-      }
-      if _storage._protobufEnumMap != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufEnumMap, fieldNumber: 683)
-      }
-      if _storage._protobufExtension != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufExtension, fieldNumber: 684)
-      }
-      if _storage._protobufFixed32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufFixed32, fieldNumber: 685)
-      }
-      if _storage._protobufFixed64 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufFixed64, fieldNumber: 686)
-      }
-      if _storage._protobufFloat != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufFloat, fieldNumber: 687)
-      }
-      if _storage._protobufInt32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufInt32, fieldNumber: 688)
-      }
-      if _storage._protobufInt64 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufInt64, fieldNumber: 689)
-      }
-      if _storage._protobufMap != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufMap, fieldNumber: 690)
-      }
-      if _storage._protobufMessageMap != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufMessageMap, fieldNumber: 691)
-      }
-      if _storage._protobufSfixed32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufSfixed32, fieldNumber: 692)
-      }
-      if _storage._protobufSfixed64 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufSfixed64, fieldNumber: 693)
-      }
-      if _storage._protobufSint32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufSint32, fieldNumber: 694)
-      }
-      if _storage._protobufSint64 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufSint64, fieldNumber: 695)
-      }
-      if _storage._protobufString != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufString, fieldNumber: 696)
-      }
-      if _storage._protobufUint32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufUint32, fieldNumber: 697)
-      }
-      if _storage._protobufUint64 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufUint64, fieldNumber: 698)
-      }
-      if _storage._protobufExtensionFieldValues != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufExtensionFieldValues, fieldNumber: 699)
-      }
-      if _storage._protobufFieldNumber != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufFieldNumber, fieldNumber: 700)
-      }
-      if _storage._protobufGeneratedIsEqualTo != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufGeneratedIsEqualTo, fieldNumber: 701)
-      }
-      if _storage._protobufNameMap != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufNameMap, fieldNumber: 702)
-      }
-      if _storage._protobufNewField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufNewField, fieldNumber: 703)
-      }
-      if _storage._protobufPackage != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protobufPackage, fieldNumber: 704)
-      }
-      if _storage._protocol != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protocol, fieldNumber: 705)
-      }
-      if _storage._protoFieldName != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protoFieldName, fieldNumber: 706)
-      }
-      if _storage._protoMessageName != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protoMessageName, fieldNumber: 707)
-      }
-      if _storage._protoNameProviding != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protoNameProviding, fieldNumber: 708)
-      }
-      if _storage._protoPaths != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._protoPaths, fieldNumber: 709)
-      }
-      if _storage._public != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._public, fieldNumber: 710)
-      }
-      if _storage._publicDependency != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._publicDependency, fieldNumber: 711)
-      }
-      if _storage._putBoolValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putBoolValue, fieldNumber: 712)
-      }
-      if _storage._putBytesValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putBytesValue, fieldNumber: 713)
-      }
-      if _storage._putDoubleValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putDoubleValue, fieldNumber: 714)
-      }
-      if _storage._putEnumValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putEnumValue, fieldNumber: 715)
-      }
-      if _storage._putFixedUint32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putFixedUint32, fieldNumber: 716)
-      }
-      if _storage._putFixedUint64 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putFixedUint64, fieldNumber: 717)
-      }
-      if _storage._putFloatValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putFloatValue, fieldNumber: 718)
-      }
-      if _storage._putInt64 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putInt64, fieldNumber: 719)
-      }
-      if _storage._putStringValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putStringValue, fieldNumber: 720)
-      }
-      if _storage._putUint64 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putUint64, fieldNumber: 721)
-      }
-      if _storage._putUint64Hex != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putUint64Hex, fieldNumber: 722)
-      }
-      if _storage._putVarInt != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putVarInt, fieldNumber: 723)
-      }
-      if _storage._putZigZagVarInt != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._putZigZagVarInt, fieldNumber: 724)
-      }
-      if _storage._pyGenericServices != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._pyGenericServices, fieldNumber: 725)
-      }
-      if _storage._r != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._r, fieldNumber: 726)
-      }
-      if _storage._rawChars != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._rawChars, fieldNumber: 727)
-      }
-      if _storage._rawRepresentable != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._rawRepresentable, fieldNumber: 728)
-      }
-      if _storage._rawValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._rawValue, fieldNumber: 729)
-      }
-      if _storage._read4HexDigits != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._read4HexDigits, fieldNumber: 730)
-      }
-      if _storage._readBytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._readBytes, fieldNumber: 731)
-      }
-      if _storage._register != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._register, fieldNumber: 732)
-      }
-      if _storage._repeated != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._repeated, fieldNumber: 733)
-      }
-      if _storage._repeatedEnumExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._repeatedEnumExtensionField, fieldNumber: 734)
-      }
-      if _storage._repeatedExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._repeatedExtensionField, fieldNumber: 735)
-      }
-      if _storage._repeatedFieldEncoding != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._repeatedFieldEncoding, fieldNumber: 736)
-      }
-      if _storage._repeatedGroupExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._repeatedGroupExtensionField, fieldNumber: 737)
-      }
-      if _storage._repeatedMessageExtensionField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._repeatedMessageExtensionField, fieldNumber: 738)
-      }
-      if _storage._repeating != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._repeating, fieldNumber: 739)
-      }
-      if _storage._requestStreaming != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._requestStreaming, fieldNumber: 740)
-      }
-      if _storage._requestTypeURL != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._requestTypeURL, fieldNumber: 741)
-      }
-      if _storage._requiredSize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._requiredSize, fieldNumber: 742)
-      }
-      if _storage._responseStreaming != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._responseStreaming, fieldNumber: 743)
-      }
-      if _storage._responseTypeURL != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._responseTypeURL, fieldNumber: 744)
-      }
-      if _storage._result != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._result, fieldNumber: 745)
-      }
-      if _storage._retention != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._retention, fieldNumber: 746)
-      }
-      if _storage._rethrows != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._rethrows, fieldNumber: 747)
-      }
-      if _storage._return != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._return, fieldNumber: 748)
-      }
-      if _storage._returnType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._returnType, fieldNumber: 749)
-      }
-      if _storage._revision != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._revision, fieldNumber: 750)
-      }
-      if _storage._rhs != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._rhs, fieldNumber: 751)
-      }
-      if _storage._root != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._root, fieldNumber: 752)
-      }
-      if _storage._rubyPackage != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._rubyPackage, fieldNumber: 753)
-      }
-      if _storage._s != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._s, fieldNumber: 754)
-      }
-      if _storage._sawBackslash != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._sawBackslash, fieldNumber: 755)
-      }
-      if _storage._sawSection4Characters != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._sawSection4Characters, fieldNumber: 756)
-      }
-      if _storage._sawSection5Characters != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._sawSection5Characters, fieldNumber: 757)
-      }
-      if _storage._scanner != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._scanner, fieldNumber: 758)
-      }
-      if _storage._seconds != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._seconds, fieldNumber: 759)
-      }
-      if _storage._self_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._self_p, fieldNumber: 760)
-      }
-      if _storage._semantic != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._semantic, fieldNumber: 761)
-      }
-      if _storage._sendable != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._sendable, fieldNumber: 762)
-      }
-      if _storage._separator != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._separator, fieldNumber: 763)
-      }
-      if _storage._serialize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._serialize, fieldNumber: 764)
-      }
-      if _storage._serializedBytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._serializedBytes, fieldNumber: 765)
-      }
-      if _storage._serializedData != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._serializedData, fieldNumber: 766)
-      }
-      if _storage._serializedSize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._serializedSize, fieldNumber: 767)
-      }
-      if _storage._serverStreaming != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._serverStreaming, fieldNumber: 768)
-      }
-      if _storage._service != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._service, fieldNumber: 769)
-      }
-      if _storage._serviceDescriptorProto != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._serviceDescriptorProto, fieldNumber: 770)
-      }
-      if _storage._serviceOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._serviceOptions, fieldNumber: 771)
-      }
-      if _storage._set != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._set, fieldNumber: 772)
-      }
-      if _storage._setExtensionValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._setExtensionValue, fieldNumber: 773)
-      }
-      if _storage._shift != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._shift, fieldNumber: 774)
-      }
-      if _storage._simpleExtensionMap != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._simpleExtensionMap, fieldNumber: 775)
-      }
-      if _storage._size != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._size, fieldNumber: 776)
-      }
-      if _storage._sizer != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._sizer, fieldNumber: 777)
-      }
-      if _storage._source != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._source, fieldNumber: 778)
-      }
-      if _storage._sourceCodeInfo != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._sourceCodeInfo, fieldNumber: 779)
-      }
-      if _storage._sourceContext != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._sourceContext, fieldNumber: 780)
-      }
-      if _storage._sourceEncoding != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._sourceEncoding, fieldNumber: 781)
-      }
-      if _storage._sourceFile != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._sourceFile, fieldNumber: 782)
-      }
-      if _storage._span != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._span, fieldNumber: 783)
-      }
-      if _storage._split != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._split, fieldNumber: 784)
-      }
-      if _storage._start != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._start, fieldNumber: 785)
-      }
-      if _storage._startArray != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._startArray, fieldNumber: 786)
-      }
-      if _storage._startArrayObject != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._startArrayObject, fieldNumber: 787)
-      }
-      if _storage._startField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._startField, fieldNumber: 788)
-      }
-      if _storage._startIndex != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._startIndex, fieldNumber: 789)
-      }
-      if _storage._startMessageField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._startMessageField, fieldNumber: 790)
-      }
-      if _storage._startObject != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._startObject, fieldNumber: 791)
-      }
-      if _storage._startRegularField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._startRegularField, fieldNumber: 792)
-      }
-      if _storage._state != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._state, fieldNumber: 793)
-      }
-      if _storage._static != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._static, fieldNumber: 794)
-      }
-      if _storage._staticString != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._staticString, fieldNumber: 795)
-      }
-      if _storage._storage != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._storage, fieldNumber: 796)
-      }
-      if _storage._string != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._string, fieldNumber: 797)
-      }
-      if _storage._stringLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._stringLiteral, fieldNumber: 798)
-      }
-      if _storage._stringLiteralType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._stringLiteralType, fieldNumber: 799)
-      }
-      if _storage._stringResult != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._stringResult, fieldNumber: 800)
-      }
-      if _storage._stringValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._stringValue, fieldNumber: 801)
-      }
-      if _storage._struct != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._struct, fieldNumber: 802)
-      }
-      if _storage._structValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._structValue, fieldNumber: 803)
-      }
-      if _storage._subDecoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._subDecoder, fieldNumber: 804)
-      }
-      if _storage._subscript != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._subscript, fieldNumber: 805)
-      }
-      if _storage._subVisitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._subVisitor, fieldNumber: 806)
-      }
-      if _storage._swift != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._swift, fieldNumber: 807)
-      }
-      if _storage._swiftPrefix != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._swiftPrefix, fieldNumber: 808)
-      }
-      if _storage._swiftProtobufContiguousBytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._swiftProtobufContiguousBytes, fieldNumber: 809)
-      }
-      if _storage._syntax != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._syntax, fieldNumber: 810)
-      }
-      if _storage._t != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._t, fieldNumber: 811)
-      }
-      if _storage._tag != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._tag, fieldNumber: 812)
-      }
-      if _storage._targets != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._targets, fieldNumber: 813)
-      }
-      if _storage._terminator != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._terminator, fieldNumber: 814)
-      }
-      if _storage._testDecoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._testDecoder, fieldNumber: 815)
-      }
-      if _storage._text != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._text, fieldNumber: 816)
-      }
-      if _storage._textDecoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._textDecoder, fieldNumber: 817)
-      }
-      if _storage._textFormatDecoder != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._textFormatDecoder, fieldNumber: 818)
-      }
-      if _storage._textFormatDecodingError != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._textFormatDecodingError, fieldNumber: 819)
-      }
-      if _storage._textFormatDecodingOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._textFormatDecodingOptions, fieldNumber: 820)
-      }
-      if _storage._textFormatEncodingOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._textFormatEncodingOptions, fieldNumber: 821)
-      }
-      if _storage._textFormatEncodingVisitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._textFormatEncodingVisitor, fieldNumber: 822)
-      }
-      if _storage._textFormatString != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._textFormatString, fieldNumber: 823)
-      }
-      if _storage._throwOrIgnore != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._throwOrIgnore, fieldNumber: 824)
-      }
-      if _storage._throws != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._throws, fieldNumber: 825)
-      }
-      if _storage._timeInterval != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._timeInterval, fieldNumber: 826)
-      }
-      if _storage._timeIntervalSince1970 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._timeIntervalSince1970, fieldNumber: 827)
-      }
-      if _storage._timeIntervalSinceReferenceDate != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._timeIntervalSinceReferenceDate, fieldNumber: 828)
-      }
-      if _storage._timestamp != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._timestamp, fieldNumber: 829)
-      }
-      if _storage._total != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._total, fieldNumber: 830)
-      }
-      if _storage._totalArrayDepth != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._totalArrayDepth, fieldNumber: 831)
-      }
-      if _storage._totalSize != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._totalSize, fieldNumber: 832)
-      }
-      if _storage._trailingComments != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._trailingComments, fieldNumber: 833)
-      }
-      if _storage._traverse != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._traverse, fieldNumber: 834)
-      }
-      if _storage._true != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._true, fieldNumber: 835)
-      }
-      if _storage._try != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._try, fieldNumber: 836)
-      }
-      if _storage._type != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._type, fieldNumber: 837)
-      }
-      if _storage._typealias != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._typealias, fieldNumber: 838)
-      }
-      if _storage._typeEnum != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._typeEnum, fieldNumber: 839)
-      }
-      if _storage._typeName != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._typeName, fieldNumber: 840)
-      }
-      if _storage._typePrefix != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._typePrefix, fieldNumber: 841)
-      }
-      if _storage._typeStart != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._typeStart, fieldNumber: 842)
-      }
-      if _storage._typeUnknown != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._typeUnknown, fieldNumber: 843)
-      }
-      if _storage._typeURL != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._typeURL, fieldNumber: 844)
-      }
-      if _storage._uint32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._uint32, fieldNumber: 845)
-      }
-      if _storage._uint32Value != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._uint32Value, fieldNumber: 846)
-      }
-      if _storage._uint64 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._uint64, fieldNumber: 847)
-      }
-      if _storage._uint64Value != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._uint64Value, fieldNumber: 848)
-      }
-      if _storage._uint8 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._uint8, fieldNumber: 849)
-      }
-      if _storage._unchecked != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unchecked, fieldNumber: 850)
-      }
-      if _storage._unicodeScalarLiteral != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unicodeScalarLiteral, fieldNumber: 851)
-      }
-      if _storage._unicodeScalarLiteralType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unicodeScalarLiteralType, fieldNumber: 852)
-      }
-      if _storage._unicodeScalars != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unicodeScalars, fieldNumber: 853)
-      }
-      if _storage._unicodeScalarView != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unicodeScalarView, fieldNumber: 854)
-      }
-      if _storage._uninterpretedOption != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._uninterpretedOption, fieldNumber: 855)
-      }
-      if _storage._union != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._union, fieldNumber: 856)
-      }
-      if _storage._uniqueStorage != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._uniqueStorage, fieldNumber: 857)
-      }
-      if _storage._unknown != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unknown, fieldNumber: 858)
-      }
-      if _storage._unknownFields_p != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unknownFields_p, fieldNumber: 859)
-      }
-      if _storage._unknownStorage != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unknownStorage, fieldNumber: 860)
-      }
-      if _storage._unpackTo != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unpackTo, fieldNumber: 861)
-      }
-      if _storage._unsafeBufferPointer != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unsafeBufferPointer, fieldNumber: 862)
-      }
-      if _storage._unsafeMutablePointer != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unsafeMutablePointer, fieldNumber: 863)
-      }
-      if _storage._unsafeMutableRawBufferPointer != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unsafeMutableRawBufferPointer, fieldNumber: 864)
-      }
-      if _storage._unsafeRawBufferPointer != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unsafeRawBufferPointer, fieldNumber: 865)
-      }
-      if _storage._unsafeRawPointer != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unsafeRawPointer, fieldNumber: 866)
-      }
-      if _storage._unverifiedLazy != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._unverifiedLazy, fieldNumber: 867)
-      }
-      if _storage._updatedOptions != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._updatedOptions, fieldNumber: 868)
-      }
-      if _storage._url != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._url, fieldNumber: 869)
-      }
-      if _storage._useDeterministicOrdering != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._useDeterministicOrdering, fieldNumber: 870)
-      }
-      if _storage._utf8 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._utf8, fieldNumber: 871)
-      }
-      if _storage._utf8Ptr != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._utf8Ptr, fieldNumber: 872)
-      }
-      if _storage._utf8ToDouble != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._utf8ToDouble, fieldNumber: 873)
-      }
-      if _storage._utf8Validation != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._utf8Validation, fieldNumber: 874)
-      }
-      if _storage._utf8View != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._utf8View, fieldNumber: 875)
-      }
-      if _storage._v != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._v, fieldNumber: 876)
-      }
-      if _storage._value != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._value, fieldNumber: 877)
-      }
-      if _storage._valueField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._valueField, fieldNumber: 878)
-      }
-      if _storage._values != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._values, fieldNumber: 879)
-      }
-      if _storage._valueType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._valueType, fieldNumber: 880)
-      }
-      if _storage._var != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._var, fieldNumber: 881)
-      }
-      if _storage._verification != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._verification, fieldNumber: 882)
-      }
-      if _storage._verificationState != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._verificationState, fieldNumber: 883)
-      }
-      if _storage._version != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._version, fieldNumber: 884)
-      }
-      if _storage._versionString != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._versionString, fieldNumber: 885)
-      }
-      if _storage._visitExtensionFields != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitExtensionFields, fieldNumber: 886)
-      }
-      if _storage._visitExtensionFieldsAsMessageSet != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitExtensionFieldsAsMessageSet, fieldNumber: 887)
-      }
-      if _storage._visitMapField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitMapField, fieldNumber: 888)
-      }
-      if _storage._visitor != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitor, fieldNumber: 889)
-      }
-      if _storage._visitPacked != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPacked, fieldNumber: 890)
-      }
-      if _storage._visitPackedBoolField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedBoolField, fieldNumber: 891)
-      }
-      if _storage._visitPackedDoubleField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedDoubleField, fieldNumber: 892)
-      }
-      if _storage._visitPackedEnumField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedEnumField, fieldNumber: 893)
-      }
-      if _storage._visitPackedFixed32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedFixed32Field, fieldNumber: 894)
-      }
-      if _storage._visitPackedFixed64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedFixed64Field, fieldNumber: 895)
-      }
-      if _storage._visitPackedFloatField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedFloatField, fieldNumber: 896)
-      }
-      if _storage._visitPackedInt32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedInt32Field, fieldNumber: 897)
-      }
-      if _storage._visitPackedInt64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedInt64Field, fieldNumber: 898)
-      }
-      if _storage._visitPackedSfixed32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedSfixed32Field, fieldNumber: 899)
-      }
-      if _storage._visitPackedSfixed64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedSfixed64Field, fieldNumber: 900)
-      }
-      if _storage._visitPackedSint32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedSint32Field, fieldNumber: 901)
-      }
-      if _storage._visitPackedSint64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedSint64Field, fieldNumber: 902)
-      }
-      if _storage._visitPackedUint32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedUint32Field, fieldNumber: 903)
-      }
-      if _storage._visitPackedUint64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitPackedUint64Field, fieldNumber: 904)
-      }
-      if _storage._visitRepeated != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeated, fieldNumber: 905)
-      }
-      if _storage._visitRepeatedBoolField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedBoolField, fieldNumber: 906)
-      }
-      if _storage._visitRepeatedBytesField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedBytesField, fieldNumber: 907)
-      }
-      if _storage._visitRepeatedDoubleField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedDoubleField, fieldNumber: 908)
-      }
-      if _storage._visitRepeatedEnumField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedEnumField, fieldNumber: 909)
-      }
-      if _storage._visitRepeatedFixed32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFixed32Field, fieldNumber: 910)
-      }
-      if _storage._visitRepeatedFixed64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFixed64Field, fieldNumber: 911)
-      }
-      if _storage._visitRepeatedFloatField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFloatField, fieldNumber: 912)
-      }
-      if _storage._visitRepeatedGroupField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedGroupField, fieldNumber: 913)
-      }
-      if _storage._visitRepeatedInt32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedInt32Field, fieldNumber: 914)
-      }
-      if _storage._visitRepeatedInt64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedInt64Field, fieldNumber: 915)
-      }
-      if _storage._visitRepeatedMessageField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedMessageField, fieldNumber: 916)
-      }
-      if _storage._visitRepeatedSfixed32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSfixed32Field, fieldNumber: 917)
-      }
-      if _storage._visitRepeatedSfixed64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSfixed64Field, fieldNumber: 918)
-      }
-      if _storage._visitRepeatedSint32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSint32Field, fieldNumber: 919)
-      }
-      if _storage._visitRepeatedSint64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSint64Field, fieldNumber: 920)
-      }
-      if _storage._visitRepeatedStringField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedStringField, fieldNumber: 921)
-      }
-      if _storage._visitRepeatedUint32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedUint32Field, fieldNumber: 922)
-      }
-      if _storage._visitRepeatedUint64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitRepeatedUint64Field, fieldNumber: 923)
-      }
-      if _storage._visitSingular != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingular, fieldNumber: 924)
-      }
-      if _storage._visitSingularBoolField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularBoolField, fieldNumber: 925)
-      }
-      if _storage._visitSingularBytesField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularBytesField, fieldNumber: 926)
-      }
-      if _storage._visitSingularDoubleField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularDoubleField, fieldNumber: 927)
-      }
-      if _storage._visitSingularEnumField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularEnumField, fieldNumber: 928)
-      }
-      if _storage._visitSingularFixed32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularFixed32Field, fieldNumber: 929)
-      }
-      if _storage._visitSingularFixed64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularFixed64Field, fieldNumber: 930)
-      }
-      if _storage._visitSingularFloatField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularFloatField, fieldNumber: 931)
-      }
-      if _storage._visitSingularGroupField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularGroupField, fieldNumber: 932)
-      }
-      if _storage._visitSingularInt32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularInt32Field, fieldNumber: 933)
-      }
-      if _storage._visitSingularInt64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularInt64Field, fieldNumber: 934)
-      }
-      if _storage._visitSingularMessageField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularMessageField, fieldNumber: 935)
-      }
-      if _storage._visitSingularSfixed32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularSfixed32Field, fieldNumber: 936)
-      }
-      if _storage._visitSingularSfixed64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularSfixed64Field, fieldNumber: 937)
-      }
-      if _storage._visitSingularSint32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularSint32Field, fieldNumber: 938)
-      }
-      if _storage._visitSingularSint64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularSint64Field, fieldNumber: 939)
-      }
-      if _storage._visitSingularStringField != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularStringField, fieldNumber: 940)
-      }
-      if _storage._visitSingularUint32Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularUint32Field, fieldNumber: 941)
-      }
-      if _storage._visitSingularUint64Field != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitSingularUint64Field, fieldNumber: 942)
-      }
-      if _storage._visitUnknown != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._visitUnknown, fieldNumber: 943)
-      }
-      if _storage._wasDecoded != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._wasDecoded, fieldNumber: 944)
-      }
-      if _storage._weak != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._weak, fieldNumber: 945)
-      }
-      if _storage._weakDependency != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._weakDependency, fieldNumber: 946)
-      }
-      if _storage._where != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._where, fieldNumber: 947)
-      }
-      if _storage._wireFormat != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._wireFormat, fieldNumber: 948)
-      }
-      if _storage._with != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._with, fieldNumber: 949)
-      }
-      if _storage._withUnsafeBytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._withUnsafeBytes, fieldNumber: 950)
-      }
-      if _storage._withUnsafeMutableBytes != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._withUnsafeMutableBytes, fieldNumber: 951)
-      }
-      if _storage._work != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._work, fieldNumber: 952)
-      }
-      if _storage._wrapped != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._wrapped, fieldNumber: 953)
-      }
-      if _storage._wrappedType != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._wrappedType, fieldNumber: 954)
-      }
-      if _storage._wrappedValue != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._wrappedValue, fieldNumber: 955)
-      }
-      if _storage._written != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._written, fieldNumber: 956)
-      }
-      if _storage._yday != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._yday, fieldNumber: 957)
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.adjusted }, fieldNumber: 1),
+    .singularInt32({ $0.aggregateValue }, fieldNumber: 2),
+    .singularInt32({ $0.allCases }, fieldNumber: 3),
+    .singularInt32({ $0.allowAlias }, fieldNumber: 4),
+    .singularInt32({ $0.alwaysPrintEnumsAsInts }, fieldNumber: 5),
+    .singularInt32({ $0.alwaysPrintInt64SAsNumbers }, fieldNumber: 6),
+    .singularInt32({ $0.annotation }, fieldNumber: 7),
+    .singularInt32({ $0.any }, fieldNumber: 8),
+    .singularInt32({ $0.anyExtensionField }, fieldNumber: 9),
+    .singularInt32({ $0.anyMessageExtension }, fieldNumber: 10),
+    .singularInt32({ $0.anyMessageStorage }, fieldNumber: 11),
+    .singularInt32({ $0.anyUnpackError }, fieldNumber: 12),
+    .singularInt32({ $0.api }, fieldNumber: 13),
+    .singularInt32({ $0.appended }, fieldNumber: 14),
+    .singularInt32({ $0.appendUintHex }, fieldNumber: 15),
+    .singularInt32({ $0.appendUnknown }, fieldNumber: 16),
+    .singularInt32({ $0.areAllInitialized }, fieldNumber: 17),
+    .singularInt32({ $0.array }, fieldNumber: 18),
+    .singularInt32({ $0.arrayDepth }, fieldNumber: 19),
+    .singularInt32({ $0.arrayLiteral }, fieldNumber: 20),
+    .singularInt32({ $0.arraySeparator }, fieldNumber: 21),
+    .singularInt32({ $0.`as` }, fieldNumber: 22),
+    .singularInt32({ $0.asciiOpenCurlyBracket }, fieldNumber: 23),
+    .singularInt32({ $0.asciiZero }, fieldNumber: 24),
+    .singularInt32({ $0.async }, fieldNumber: 25),
+    .singularInt32({ $0.asyncIterator }, fieldNumber: 26),
+    .singularInt32({ $0.asyncIteratorProtocol }, fieldNumber: 27),
+    .singularInt32({ $0.asyncMessageSequence }, fieldNumber: 28),
+    .singularInt32({ $0.available }, fieldNumber: 29),
+    .singularInt32({ $0.b }, fieldNumber: 30),
+    .singularInt32({ $0.base }, fieldNumber: 31),
+    .singularInt32({ $0.base64Values }, fieldNumber: 32),
+    .singularInt32({ $0.baseAddress }, fieldNumber: 33),
+    .singularInt32({ $0.baseType }, fieldNumber: 34),
+    .singularInt32({ $0.begin }, fieldNumber: 35),
+    .singularInt32({ $0.binary }, fieldNumber: 36),
+    .singularInt32({ $0.binaryDecoder }, fieldNumber: 37),
+    .singularInt32({ $0.binaryDecodingError }, fieldNumber: 38),
+    .singularInt32({ $0.binaryDecodingOptions }, fieldNumber: 39),
+    .singularInt32({ $0.binaryDelimited }, fieldNumber: 40),
+    .singularInt32({ $0.binaryEncoder }, fieldNumber: 41),
+    .singularInt32({ $0.binaryEncodingError }, fieldNumber: 42),
+    .singularInt32({ $0.binaryEncodingMessageSetSizeVisitor }, fieldNumber: 43),
+    .singularInt32({ $0.binaryEncodingMessageSetVisitor }, fieldNumber: 44),
+    .singularInt32({ $0.binaryEncodingOptions }, fieldNumber: 45),
+    .singularInt32({ $0.binaryEncodingSizeVisitor }, fieldNumber: 46),
+    .singularInt32({ $0.binaryEncodingVisitor }, fieldNumber: 47),
+    .singularInt32({ $0.binaryOptions }, fieldNumber: 48),
+    .singularInt32({ $0.binaryProtobufDelimitedMessages }, fieldNumber: 49),
+    .singularInt32({ $0.bitPattern }, fieldNumber: 50),
+    .singularInt32({ $0.body }, fieldNumber: 51),
+    .singularInt32({ $0.bool }, fieldNumber: 52),
+    .singularInt32({ $0.booleanLiteral }, fieldNumber: 53),
+    .singularInt32({ $0.booleanLiteralType }, fieldNumber: 54),
+    .singularInt32({ $0.boolValue }, fieldNumber: 55),
+    .singularInt32({ $0.buffer }, fieldNumber: 56),
+    .singularInt32({ $0.bytes }, fieldNumber: 57),
+    .singularInt32({ $0.bytesInGroup }, fieldNumber: 58),
+    .singularInt32({ $0.bytesNeeded }, fieldNumber: 59),
+    .singularInt32({ $0.bytesRead }, fieldNumber: 60),
+    .singularInt32({ $0.bytesValue }, fieldNumber: 61),
+    .singularInt32({ $0.c }, fieldNumber: 62),
+    .singularInt32({ $0.capitalizeNext }, fieldNumber: 63),
+    .singularInt32({ $0.cardinality }, fieldNumber: 64),
+    .singularInt32({ $0.caseIterable }, fieldNumber: 65),
+    .singularInt32({ $0.ccEnableArenas }, fieldNumber: 66),
+    .singularInt32({ $0.ccGenericServices }, fieldNumber: 67),
+    .singularInt32({ $0.character }, fieldNumber: 68),
+    .singularInt32({ $0.chars }, fieldNumber: 69),
+    .singularInt32({ $0.chunk }, fieldNumber: 70),
+    .singularInt32({ $0.`class` }, fieldNumber: 71),
+    .singularInt32({ $0.clearAggregateValue_p }, fieldNumber: 72),
+    .singularInt32({ $0.clearAllowAlias_p }, fieldNumber: 73),
+    .singularInt32({ $0.clearBegin_p }, fieldNumber: 74),
+    .singularInt32({ $0.clearCcEnableArenas_p }, fieldNumber: 75),
+    .singularInt32({ $0.clearCcGenericServices_p }, fieldNumber: 76),
+    .singularInt32({ $0.clearClientStreaming_p }, fieldNumber: 77),
+    .singularInt32({ $0.clearCsharpNamespace_p }, fieldNumber: 78),
+    .singularInt32({ $0.clearCtype_p }, fieldNumber: 79),
+    .singularInt32({ $0.clearDebugRedact_p }, fieldNumber: 80),
+    .singularInt32({ $0.clearDefaultValue_p }, fieldNumber: 81),
+    .singularInt32({ $0.clearDeprecated_p }, fieldNumber: 82),
+    .singularInt32({ $0.clearDeprecatedLegacyJsonFieldConflicts_p }, fieldNumber: 83),
+    .singularInt32({ $0.clearDoubleValue_p }, fieldNumber: 84),
+    .singularInt32({ $0.clearEdition_p }, fieldNumber: 85),
+    .singularInt32({ $0.clearEnd_p }, fieldNumber: 86),
+    .singularInt32({ $0.clearEnumType_p }, fieldNumber: 87),
+    .singularInt32({ $0.clearExtendee_p }, fieldNumber: 88),
+    .singularInt32({ $0.clearExtensionValue_p }, fieldNumber: 89),
+    .singularInt32({ $0.clearFeatures_p }, fieldNumber: 90),
+    .singularInt32({ $0.clearFieldPresence_p }, fieldNumber: 91),
+    .singularInt32({ $0.clearFullName_p }, fieldNumber: 92),
+    .singularInt32({ $0.clearGoPackage_p }, fieldNumber: 93),
+    .singularInt32({ $0.clearIdempotencyLevel_p }, fieldNumber: 94),
+    .singularInt32({ $0.clearIdentifierValue_p }, fieldNumber: 95),
+    .singularInt32({ $0.clearInputType_p }, fieldNumber: 96),
+    .singularInt32({ $0.clearIsExtension_p }, fieldNumber: 97),
+    .singularInt32({ $0.clearJavaGenerateEqualsAndHash_p }, fieldNumber: 98),
+    .singularInt32({ $0.clearJavaGenericServices_p }, fieldNumber: 99),
+    .singularInt32({ $0.clearJavaMultipleFiles_p }, fieldNumber: 100),
+    .singularInt32({ $0.clearJavaOuterClassname_p }, fieldNumber: 101),
+    .singularInt32({ $0.clearJavaPackage_p }, fieldNumber: 102),
+    .singularInt32({ $0.clearJavaStringCheckUtf8_p }, fieldNumber: 103),
+    .singularInt32({ $0.clearJsonFormat_p }, fieldNumber: 104),
+    .singularInt32({ $0.clearJsonName_p }, fieldNumber: 105),
+    .singularInt32({ $0.clearJstype_p }, fieldNumber: 106),
+    .singularInt32({ $0.clearLabel_p }, fieldNumber: 107),
+    .singularInt32({ $0.clearLazy_p }, fieldNumber: 108),
+    .singularInt32({ $0.clearLeadingComments_p }, fieldNumber: 109),
+    .singularInt32({ $0.clearMapEntry_p }, fieldNumber: 110),
+    .singularInt32({ $0.clearMaximumEdition_p }, fieldNumber: 111),
+    .singularInt32({ $0.clearMessageEncoding_p }, fieldNumber: 112),
+    .singularInt32({ $0.clearMessageSetWireFormat_p }, fieldNumber: 113),
+    .singularInt32({ $0.clearMinimumEdition_p }, fieldNumber: 114),
+    .singularInt32({ $0.clearName_p }, fieldNumber: 115),
+    .singularInt32({ $0.clearNamePart_p }, fieldNumber: 116),
+    .singularInt32({ $0.clearNegativeIntValue_p }, fieldNumber: 117),
+    .singularInt32({ $0.clearNoStandardDescriptorAccessor_p }, fieldNumber: 118),
+    .singularInt32({ $0.clearNumber_p }, fieldNumber: 119),
+    .singularInt32({ $0.clearObjcClassPrefix_p }, fieldNumber: 120),
+    .singularInt32({ $0.clearOneofIndex_p }, fieldNumber: 121),
+    .singularInt32({ $0.clearOptimizeFor_p }, fieldNumber: 122),
+    .singularInt32({ $0.clearOptions_p }, fieldNumber: 123),
+    .singularInt32({ $0.clearOutputType_p }, fieldNumber: 124),
+    .singularInt32({ $0.clearPackage_p }, fieldNumber: 125),
+    .singularInt32({ $0.clearPacked_p }, fieldNumber: 126),
+    .singularInt32({ $0.clearPhpClassPrefix_p }, fieldNumber: 127),
+    .singularInt32({ $0.clearPhpGenericServices_p }, fieldNumber: 128),
+    .singularInt32({ $0.clearPhpMetadataNamespace_p }, fieldNumber: 129),
+    .singularInt32({ $0.clearPhpNamespace_p }, fieldNumber: 130),
+    .singularInt32({ $0.clearPositiveIntValue_p }, fieldNumber: 131),
+    .singularInt32({ $0.clearProto3Optional_p }, fieldNumber: 132),
+    .singularInt32({ $0.clearPyGenericServices_p }, fieldNumber: 133),
+    .singularInt32({ $0.clearRepeated_p }, fieldNumber: 134),
+    .singularInt32({ $0.clearRepeatedFieldEncoding_p }, fieldNumber: 135),
+    .singularInt32({ $0.clearReserved_p }, fieldNumber: 136),
+    .singularInt32({ $0.clearRetention_p }, fieldNumber: 137),
+    .singularInt32({ $0.clearRubyPackage_p }, fieldNumber: 138),
+    .singularInt32({ $0.clearSemantic_p }, fieldNumber: 139),
+    .singularInt32({ $0.clearServerStreaming_p }, fieldNumber: 140),
+    .singularInt32({ $0.clearSourceCodeInfo_p }, fieldNumber: 141),
+    .singularInt32({ $0.clearSourceContext_p }, fieldNumber: 142),
+    .singularInt32({ $0.clearSourceFile_p }, fieldNumber: 143),
+    .singularInt32({ $0.clearStart_p }, fieldNumber: 144),
+    .singularInt32({ $0.clearStringValue_p }, fieldNumber: 145),
+    .singularInt32({ $0.clearSwiftPrefix_p }, fieldNumber: 146),
+    .singularInt32({ $0.clearSyntax_p }, fieldNumber: 147),
+    .singularInt32({ $0.clearTrailingComments_p }, fieldNumber: 148),
+    .singularInt32({ $0.clearType_p }, fieldNumber: 149),
+    .singularInt32({ $0.clearTypeName_p }, fieldNumber: 150),
+    .singularInt32({ $0.clearUnverifiedLazy_p }, fieldNumber: 151),
+    .singularInt32({ $0.clearUtf8Validation_p }, fieldNumber: 152),
+    .singularInt32({ $0.clearValue_p }, fieldNumber: 153),
+    .singularInt32({ $0.clearVerification_p }, fieldNumber: 154),
+    .singularInt32({ $0.clearWeak_p }, fieldNumber: 155),
+    .singularInt32({ $0.clientStreaming }, fieldNumber: 156),
+    .singularInt32({ $0.codePoint }, fieldNumber: 157),
+    .singularInt32({ $0.codeUnits }, fieldNumber: 158),
+    .singularInt32({ $0.collection }, fieldNumber: 159),
+    .singularInt32({ $0.com }, fieldNumber: 160),
+    .singularInt32({ $0.comma }, fieldNumber: 161),
+    .singularInt32({ $0.commonMessageConformances }, fieldNumber: 162),
+    .singularInt32({ $0.consumedBytes }, fieldNumber: 163),
+    .singularInt32({ $0.contentsOf }, fieldNumber: 164),
+    .singularInt32({ $0.count }, fieldNumber: 165),
+    .singularInt32({ $0.countVarintsInBuffer }, fieldNumber: 166),
+    .singularInt32({ $0.csharpNamespace }, fieldNumber: 167),
+    .singularInt32({ $0.ctype }, fieldNumber: 168),
+    .singularInt32({ $0.customCodable }, fieldNumber: 169),
+    .singularInt32({ $0.d }, fieldNumber: 170),
+    .singularInt32({ $0.data }, fieldNumber: 171),
+    .singularInt32({ $0.dataResult }, fieldNumber: 172),
+    .singularInt32({ $0.date }, fieldNumber: 173),
+    .singularInt32({ $0.daySec }, fieldNumber: 174),
+    .singularInt32({ $0.daysSinceEpoch }, fieldNumber: 175),
+    .singularInt32({ $0.debugDescription_p }, fieldNumber: 176),
+    .singularInt32({ $0.debugRedact }, fieldNumber: 177),
+    .singularInt32({ $0.declaration }, fieldNumber: 178),
+    .singularInt32({ $0.decoded }, fieldNumber: 179),
+    .singularInt32({ $0.decodedFromJsonnull }, fieldNumber: 180),
+    .singularInt32({ $0.decodeExtensionField }, fieldNumber: 181),
+    .singularInt32({ $0.decodeExtensionFieldsAsMessageSet }, fieldNumber: 182),
+    .singularInt32({ $0.decodeJson }, fieldNumber: 183),
+    .singularInt32({ $0.decodeMapField }, fieldNumber: 184),
+    .singularInt32({ $0.decodeMessage }, fieldNumber: 185),
+    .singularInt32({ $0.decoder }, fieldNumber: 186),
+    .singularInt32({ $0.decodeRepeated }, fieldNumber: 187),
+    .singularInt32({ $0.decodeRepeatedBoolField }, fieldNumber: 188),
+    .singularInt32({ $0.decodeRepeatedBytesField }, fieldNumber: 189),
+    .singularInt32({ $0.decodeRepeatedDoubleField }, fieldNumber: 190),
+    .singularInt32({ $0.decodeRepeatedEnumField }, fieldNumber: 191),
+    .singularInt32({ $0.decodeRepeatedFixed32Field }, fieldNumber: 192),
+    .singularInt32({ $0.decodeRepeatedFixed64Field }, fieldNumber: 193),
+    .singularInt32({ $0.decodeRepeatedFloatField }, fieldNumber: 194),
+    .singularInt32({ $0.decodeRepeatedGroupField }, fieldNumber: 195),
+    .singularInt32({ $0.decodeRepeatedInt32Field }, fieldNumber: 196),
+    .singularInt32({ $0.decodeRepeatedInt64Field }, fieldNumber: 197),
+    .singularInt32({ $0.decodeRepeatedMessageField }, fieldNumber: 198),
+    .singularInt32({ $0.decodeRepeatedSfixed32Field }, fieldNumber: 199),
+    .singularInt32({ $0.decodeRepeatedSfixed64Field }, fieldNumber: 200),
+    .singularInt32({ $0.decodeRepeatedSint32Field }, fieldNumber: 201),
+    .singularInt32({ $0.decodeRepeatedSint64Field }, fieldNumber: 202),
+    .singularInt32({ $0.decodeRepeatedStringField }, fieldNumber: 203),
+    .singularInt32({ $0.decodeRepeatedUint32Field }, fieldNumber: 204),
+    .singularInt32({ $0.decodeRepeatedUint64Field }, fieldNumber: 205),
+    .singularInt32({ $0.decodeSingular }, fieldNumber: 206),
+    .singularInt32({ $0.decodeSingularBoolField }, fieldNumber: 207),
+    .singularInt32({ $0.decodeSingularBytesField }, fieldNumber: 208),
+    .singularInt32({ $0.decodeSingularDoubleField }, fieldNumber: 209),
+    .singularInt32({ $0.decodeSingularEnumField }, fieldNumber: 210),
+    .singularInt32({ $0.decodeSingularFixed32Field }, fieldNumber: 211),
+    .singularInt32({ $0.decodeSingularFixed64Field }, fieldNumber: 212),
+    .singularInt32({ $0.decodeSingularFloatField }, fieldNumber: 213),
+    .singularInt32({ $0.decodeSingularGroupField }, fieldNumber: 214),
+    .singularInt32({ $0.decodeSingularInt32Field }, fieldNumber: 215),
+    .singularInt32({ $0.decodeSingularInt64Field }, fieldNumber: 216),
+    .singularInt32({ $0.decodeSingularMessageField }, fieldNumber: 217),
+    .singularInt32({ $0.decodeSingularSfixed32Field }, fieldNumber: 218),
+    .singularInt32({ $0.decodeSingularSfixed64Field }, fieldNumber: 219),
+    .singularInt32({ $0.decodeSingularSint32Field }, fieldNumber: 220),
+    .singularInt32({ $0.decodeSingularSint64Field }, fieldNumber: 221),
+    .singularInt32({ $0.decodeSingularStringField }, fieldNumber: 222),
+    .singularInt32({ $0.decodeSingularUint32Field }, fieldNumber: 223),
+    .singularInt32({ $0.decodeSingularUint64Field }, fieldNumber: 224),
+    .singularInt32({ $0.decodeTextFormat }, fieldNumber: 225),
+    .singularInt32({ $0.defaultAnyTypeUrlprefix }, fieldNumber: 226),
+    .singularInt32({ $0.defaults }, fieldNumber: 227),
+    .singularInt32({ $0.defaultValue }, fieldNumber: 228),
+    .singularInt32({ $0.dependency }, fieldNumber: 229),
+    .singularInt32({ $0.deprecated }, fieldNumber: 230),
+    .singularInt32({ $0.deprecatedLegacyJsonFieldConflicts }, fieldNumber: 231),
+    .singularInt32({ $0.description_p }, fieldNumber: 232),
+    .singularInt32({ $0.descriptorProto }, fieldNumber: 233),
+    .singularInt32({ $0.dictionary }, fieldNumber: 234),
+    .singularInt32({ $0.dictionaryLiteral }, fieldNumber: 235),
+    .singularInt32({ $0.digit }, fieldNumber: 236),
+    .singularInt32({ $0.digit0 }, fieldNumber: 237),
+    .singularInt32({ $0.digit1 }, fieldNumber: 238),
+    .singularInt32({ $0.digitCount }, fieldNumber: 239),
+    .singularInt32({ $0.digits }, fieldNumber: 240),
+    .singularInt32({ $0.digitValue }, fieldNumber: 241),
+    .singularInt32({ $0.discardableResult }, fieldNumber: 242),
+    .singularInt32({ $0.discardUnknownFields }, fieldNumber: 243),
+    .singularInt32({ $0.double }, fieldNumber: 244),
+    .singularInt32({ $0.doubleValue }, fieldNumber: 245),
+    .singularInt32({ $0.duration }, fieldNumber: 246),
+    .singularInt32({ $0.e }, fieldNumber: 247),
+    .singularInt32({ $0.edition }, fieldNumber: 248),
+    .singularInt32({ $0.editionDefault }, fieldNumber: 249),
+    .singularInt32({ $0.editionDefaults }, fieldNumber: 250),
+    .singularInt32({ $0.element }, fieldNumber: 251),
+    .singularInt32({ $0.elements }, fieldNumber: 252),
+    .singularInt32({ $0.emitExtensionFieldName }, fieldNumber: 253),
+    .singularInt32({ $0.emitFieldName }, fieldNumber: 254),
+    .singularInt32({ $0.emitFieldNumber }, fieldNumber: 255),
+    .singularInt32({ $0.empty }, fieldNumber: 256),
+    .singularInt32({ $0.encodeAsBytes }, fieldNumber: 257),
+    .singularInt32({ $0.encoded }, fieldNumber: 258),
+    .singularInt32({ $0.encodedJsonstring }, fieldNumber: 259),
+    .singularInt32({ $0.encodedSize }, fieldNumber: 260),
+    .singularInt32({ $0.encodeField }, fieldNumber: 261),
+    .singularInt32({ $0.encoder }, fieldNumber: 262),
+    .singularInt32({ $0.end }, fieldNumber: 263),
+    .singularInt32({ $0.endArray }, fieldNumber: 264),
+    .singularInt32({ $0.endMessageField }, fieldNumber: 265),
+    .singularInt32({ $0.endObject }, fieldNumber: 266),
+    .singularInt32({ $0.endRegularField }, fieldNumber: 267),
+    .singularInt32({ $0.`enum` }, fieldNumber: 268),
+    .singularInt32({ $0.enumDescriptorProto }, fieldNumber: 269),
+    .singularInt32({ $0.enumOptions }, fieldNumber: 270),
+    .singularInt32({ $0.enumReservedRange }, fieldNumber: 271),
+    .singularInt32({ $0.enumType }, fieldNumber: 272),
+    .singularInt32({ $0.enumvalue }, fieldNumber: 273),
+    .singularInt32({ $0.enumValueDescriptorProto }, fieldNumber: 274),
+    .singularInt32({ $0.enumValueOptions }, fieldNumber: 275),
+    .singularInt32({ $0.equatable }, fieldNumber: 276),
+    .singularInt32({ $0.error }, fieldNumber: 277),
+    .singularInt32({ $0.escaping }, fieldNumber: 278),
+    .singularInt32({ $0.expressibleByArrayLiteral }, fieldNumber: 279),
+    .singularInt32({ $0.expressibleByDictionaryLiteral }, fieldNumber: 280),
+    .singularInt32({ $0.ext }, fieldNumber: 281),
+    .singularInt32({ $0.extDecoder }, fieldNumber: 282),
+    .singularInt32({ $0.extendedGraphemeClusterLiteral }, fieldNumber: 283),
+    .singularInt32({ $0.extendedGraphemeClusterLiteralType }, fieldNumber: 284),
+    .singularInt32({ $0.extendee }, fieldNumber: 285),
+    .singularInt32({ $0.extensibleMessage }, fieldNumber: 286),
+    .singularInt32({ $0.`extension` }, fieldNumber: 287),
+    .singularInt32({ $0.extensionField }, fieldNumber: 288),
+    .singularInt32({ $0.extensionFieldNumber }, fieldNumber: 289),
+    .singularInt32({ $0.extensionFields }, fieldNumber: 290),
+    .singularInt32({ $0.extensionFieldsAsMessageSet }, fieldNumber: 291),
+    .singularInt32({ $0.extensionFieldValueSet }, fieldNumber: 292),
+    .singularInt32({ $0.extensionMap }, fieldNumber: 293),
+    .singularInt32({ $0.extensionRange }, fieldNumber: 294),
+    .singularInt32({ $0.extensionRangeOptions }, fieldNumber: 295),
+    .singularInt32({ $0.extensions }, fieldNumber: 296),
+    .singularInt32({ $0.extras }, fieldNumber: 297),
+    .singularInt32({ $0.f }, fieldNumber: 298),
+    .singularInt32({ $0.`false` }, fieldNumber: 299),
+    .singularInt32({ $0.features }, fieldNumber: 300),
+    .singularInt32({ $0.featureSet }, fieldNumber: 301),
+    .singularInt32({ $0.featureSetDefaults }, fieldNumber: 302),
+    .singularInt32({ $0.featureSetEditionDefault }, fieldNumber: 303),
+    .singularInt32({ $0.field }, fieldNumber: 304),
+    .singularInt32({ $0.fieldData }, fieldNumber: 305),
+    .singularInt32({ $0.fieldDescriptorProto }, fieldNumber: 306),
+    .singularInt32({ $0.fieldMask }, fieldNumber: 307),
+    .singularInt32({ $0.fieldName }, fieldNumber: 308),
+    .singularInt32({ $0.fieldNameCount }, fieldNumber: 309),
+    .singularInt32({ $0.fieldNum }, fieldNumber: 310),
+    .singularInt32({ $0.fieldNumber }, fieldNumber: 311),
+    .singularInt32({ $0.fieldNumberForProto }, fieldNumber: 312),
+    .singularInt32({ $0.fieldOptions }, fieldNumber: 313),
+    .singularInt32({ $0.fieldPresence }, fieldNumber: 314),
+    .singularInt32({ $0.fields }, fieldNumber: 315),
+    .singularInt32({ $0.fieldSize }, fieldNumber: 316),
+    .singularInt32({ $0.fieldTag }, fieldNumber: 317),
+    .singularInt32({ $0.fieldType }, fieldNumber: 318),
+    .singularInt32({ $0.file }, fieldNumber: 319),
+    .singularInt32({ $0.fileDescriptorProto }, fieldNumber: 320),
+    .singularInt32({ $0.fileDescriptorSet }, fieldNumber: 321),
+    .singularInt32({ $0.fileName }, fieldNumber: 322),
+    .singularInt32({ $0.fileOptions }, fieldNumber: 323),
+    .singularInt32({ $0.filter }, fieldNumber: 324),
+    .singularInt32({ $0.final }, fieldNumber: 325),
+    .singularInt32({ $0.first }, fieldNumber: 326),
+    .singularInt32({ $0.firstItem }, fieldNumber: 327),
+    .singularInt32({ $0.float }, fieldNumber: 328),
+    .singularInt32({ $0.floatLiteral }, fieldNumber: 329),
+    .singularInt32({ $0.floatLiteralType }, fieldNumber: 330),
+    .singularInt32({ $0.floatValue }, fieldNumber: 331),
+    .singularInt32({ $0.forMessageName }, fieldNumber: 332),
+    .singularInt32({ $0.formUnion }, fieldNumber: 333),
+    .singularInt32({ $0.forReadingFrom }, fieldNumber: 334),
+    .singularInt32({ $0.forTypeURL }, fieldNumber: 335),
+    .singularInt32({ $0.forwardParser }, fieldNumber: 336),
+    .singularInt32({ $0.forWritingInto }, fieldNumber: 337),
+    .singularInt32({ $0.from }, fieldNumber: 338),
+    .singularInt32({ $0.fromAscii2 }, fieldNumber: 339),
+    .singularInt32({ $0.fromAscii4 }, fieldNumber: 340),
+    .singularInt32({ $0.fromByteOffset }, fieldNumber: 341),
+    .singularInt32({ $0.fromHexDigit }, fieldNumber: 342),
+    .singularInt32({ $0.fullName }, fieldNumber: 343),
+    .singularInt32({ $0.`func` }, fieldNumber: 344),
+    .singularInt32({ $0.g }, fieldNumber: 345),
+    .singularInt32({ $0.generatedCodeInfo }, fieldNumber: 346),
+    .singularInt32({ $0.get }, fieldNumber: 347),
+    .singularInt32({ $0.getExtensionValue }, fieldNumber: 348),
+    .singularInt32({ $0.getValue }, fieldNumber: 349),
+    .singularInt32({ $0.googleapis }, fieldNumber: 350),
+    .singularInt32({ $0.googleProtobufAny }, fieldNumber: 351),
+    .singularInt32({ $0.googleProtobufApi }, fieldNumber: 352),
+    .singularInt32({ $0.googleProtobufBoolValue }, fieldNumber: 353),
+    .singularInt32({ $0.googleProtobufBytesValue }, fieldNumber: 354),
+    .singularInt32({ $0.googleProtobufDescriptorProto }, fieldNumber: 355),
+    .singularInt32({ $0.googleProtobufDoubleValue }, fieldNumber: 356),
+    .singularInt32({ $0.googleProtobufDuration }, fieldNumber: 357),
+    .singularInt32({ $0.googleProtobufEdition }, fieldNumber: 358),
+    .singularInt32({ $0.googleProtobufEmpty }, fieldNumber: 359),
+    .singularInt32({ $0.googleProtobufEnum }, fieldNumber: 360),
+    .singularInt32({ $0.googleProtobufEnumDescriptorProto }, fieldNumber: 361),
+    .singularInt32({ $0.googleProtobufEnumOptions }, fieldNumber: 362),
+    .singularInt32({ $0.googleProtobufEnumValue }, fieldNumber: 363),
+    .singularInt32({ $0.googleProtobufEnumValueDescriptorProto }, fieldNumber: 364),
+    .singularInt32({ $0.googleProtobufEnumValueOptions }, fieldNumber: 365),
+    .singularInt32({ $0.googleProtobufExtensionRangeOptions }, fieldNumber: 366),
+    .singularInt32({ $0.googleProtobufFeatureSet }, fieldNumber: 367),
+    .singularInt32({ $0.googleProtobufFeatureSetDefaults }, fieldNumber: 368),
+    .singularInt32({ $0.googleProtobufField }, fieldNumber: 369),
+    .singularInt32({ $0.googleProtobufFieldDescriptorProto }, fieldNumber: 370),
+    .singularInt32({ $0.googleProtobufFieldMask }, fieldNumber: 371),
+    .singularInt32({ $0.googleProtobufFieldOptions }, fieldNumber: 372),
+    .singularInt32({ $0.googleProtobufFileDescriptorProto }, fieldNumber: 373),
+    .singularInt32({ $0.googleProtobufFileDescriptorSet }, fieldNumber: 374),
+    .singularInt32({ $0.googleProtobufFileOptions }, fieldNumber: 375),
+    .singularInt32({ $0.googleProtobufFloatValue }, fieldNumber: 376),
+    .singularInt32({ $0.googleProtobufGeneratedCodeInfo }, fieldNumber: 377),
+    .singularInt32({ $0.googleProtobufInt32Value }, fieldNumber: 378),
+    .singularInt32({ $0.googleProtobufInt64Value }, fieldNumber: 379),
+    .singularInt32({ $0.googleProtobufListValue }, fieldNumber: 380),
+    .singularInt32({ $0.googleProtobufMessageOptions }, fieldNumber: 381),
+    .singularInt32({ $0.googleProtobufMethod }, fieldNumber: 382),
+    .singularInt32({ $0.googleProtobufMethodDescriptorProto }, fieldNumber: 383),
+    .singularInt32({ $0.googleProtobufMethodOptions }, fieldNumber: 384),
+    .singularInt32({ $0.googleProtobufMixin }, fieldNumber: 385),
+    .singularInt32({ $0.googleProtobufNullValue }, fieldNumber: 386),
+    .singularInt32({ $0.googleProtobufOneofDescriptorProto }, fieldNumber: 387),
+    .singularInt32({ $0.googleProtobufOneofOptions }, fieldNumber: 388),
+    .singularInt32({ $0.googleProtobufOption }, fieldNumber: 389),
+    .singularInt32({ $0.googleProtobufServiceDescriptorProto }, fieldNumber: 390),
+    .singularInt32({ $0.googleProtobufServiceOptions }, fieldNumber: 391),
+    .singularInt32({ $0.googleProtobufSourceCodeInfo }, fieldNumber: 392),
+    .singularInt32({ $0.googleProtobufSourceContext }, fieldNumber: 393),
+    .singularInt32({ $0.googleProtobufStringValue }, fieldNumber: 394),
+    .singularInt32({ $0.googleProtobufStruct }, fieldNumber: 395),
+    .singularInt32({ $0.googleProtobufSyntax }, fieldNumber: 396),
+    .singularInt32({ $0.googleProtobufTimestamp }, fieldNumber: 397),
+    .singularInt32({ $0.googleProtobufType }, fieldNumber: 398),
+    .singularInt32({ $0.googleProtobufUint32Value }, fieldNumber: 399),
+    .singularInt32({ $0.googleProtobufUint64Value }, fieldNumber: 400),
+    .singularInt32({ $0.googleProtobufUninterpretedOption }, fieldNumber: 401),
+    .singularInt32({ $0.googleProtobufValue }, fieldNumber: 402),
+    .singularInt32({ $0.goPackage }, fieldNumber: 403),
+    .singularInt32({ $0.group }, fieldNumber: 404),
+    .singularInt32({ $0.groupFieldNumberStack }, fieldNumber: 405),
+    .singularInt32({ $0.groupSize }, fieldNumber: 406),
+    .singularInt32({ $0.hadOneofValue }, fieldNumber: 407),
+    .singularInt32({ $0.handleConflictingOneOf }, fieldNumber: 408),
+    .singularInt32({ $0.hasAggregateValue_p }, fieldNumber: 409),
+    .singularInt32({ $0.hasAllowAlias_p }, fieldNumber: 410),
+    .singularInt32({ $0.hasBegin_p }, fieldNumber: 411),
+    .singularInt32({ $0.hasCcEnableArenas_p }, fieldNumber: 412),
+    .singularInt32({ $0.hasCcGenericServices_p }, fieldNumber: 413),
+    .singularInt32({ $0.hasClientStreaming_p }, fieldNumber: 414),
+    .singularInt32({ $0.hasCsharpNamespace_p }, fieldNumber: 415),
+    .singularInt32({ $0.hasCtype_p }, fieldNumber: 416),
+    .singularInt32({ $0.hasDebugRedact_p }, fieldNumber: 417),
+    .singularInt32({ $0.hasDefaultValue_p }, fieldNumber: 418),
+    .singularInt32({ $0.hasDeprecated_p }, fieldNumber: 419),
+    .singularInt32({ $0.hasDeprecatedLegacyJsonFieldConflicts_p }, fieldNumber: 420),
+    .singularInt32({ $0.hasDoubleValue_p }, fieldNumber: 421),
+    .singularInt32({ $0.hasEdition_p }, fieldNumber: 422),
+    .singularInt32({ $0.hasEnd_p }, fieldNumber: 423),
+    .singularInt32({ $0.hasEnumType_p }, fieldNumber: 424),
+    .singularInt32({ $0.hasExtendee_p }, fieldNumber: 425),
+    .singularInt32({ $0.hasExtensionValue_p }, fieldNumber: 426),
+    .singularInt32({ $0.hasFeatures_p }, fieldNumber: 427),
+    .singularInt32({ $0.hasFieldPresence_p }, fieldNumber: 428),
+    .singularInt32({ $0.hasFullName_p }, fieldNumber: 429),
+    .singularInt32({ $0.hasGoPackage_p }, fieldNumber: 430),
+    .singularInt32({ $0.hash }, fieldNumber: 431),
+    .singularInt32({ $0.hashable }, fieldNumber: 432),
+    .singularInt32({ $0.hasher }, fieldNumber: 433),
+    .singularInt32({ $0.hashVisitor }, fieldNumber: 434),
+    .singularInt32({ $0.hasIdempotencyLevel_p }, fieldNumber: 435),
+    .singularInt32({ $0.hasIdentifierValue_p }, fieldNumber: 436),
+    .singularInt32({ $0.hasInputType_p }, fieldNumber: 437),
+    .singularInt32({ $0.hasIsExtension_p }, fieldNumber: 438),
+    .singularInt32({ $0.hasJavaGenerateEqualsAndHash_p }, fieldNumber: 439),
+    .singularInt32({ $0.hasJavaGenericServices_p }, fieldNumber: 440),
+    .singularInt32({ $0.hasJavaMultipleFiles_p }, fieldNumber: 441),
+    .singularInt32({ $0.hasJavaOuterClassname_p }, fieldNumber: 442),
+    .singularInt32({ $0.hasJavaPackage_p }, fieldNumber: 443),
+    .singularInt32({ $0.hasJavaStringCheckUtf8_p }, fieldNumber: 444),
+    .singularInt32({ $0.hasJsonFormat_p }, fieldNumber: 445),
+    .singularInt32({ $0.hasJsonName_p }, fieldNumber: 446),
+    .singularInt32({ $0.hasJstype_p }, fieldNumber: 447),
+    .singularInt32({ $0.hasLabel_p }, fieldNumber: 448),
+    .singularInt32({ $0.hasLazy_p }, fieldNumber: 449),
+    .singularInt32({ $0.hasLeadingComments_p }, fieldNumber: 450),
+    .singularInt32({ $0.hasMapEntry_p }, fieldNumber: 451),
+    .singularInt32({ $0.hasMaximumEdition_p }, fieldNumber: 452),
+    .singularInt32({ $0.hasMessageEncoding_p }, fieldNumber: 453),
+    .singularInt32({ $0.hasMessageSetWireFormat_p }, fieldNumber: 454),
+    .singularInt32({ $0.hasMinimumEdition_p }, fieldNumber: 455),
+    .singularInt32({ $0.hasName_p }, fieldNumber: 456),
+    .singularInt32({ $0.hasNamePart_p }, fieldNumber: 457),
+    .singularInt32({ $0.hasNegativeIntValue_p }, fieldNumber: 458),
+    .singularInt32({ $0.hasNoStandardDescriptorAccessor_p }, fieldNumber: 459),
+    .singularInt32({ $0.hasNumber_p }, fieldNumber: 460),
+    .singularInt32({ $0.hasObjcClassPrefix_p }, fieldNumber: 461),
+    .singularInt32({ $0.hasOneofIndex_p }, fieldNumber: 462),
+    .singularInt32({ $0.hasOptimizeFor_p }, fieldNumber: 463),
+    .singularInt32({ $0.hasOptions_p }, fieldNumber: 464),
+    .singularInt32({ $0.hasOutputType_p }, fieldNumber: 465),
+    .singularInt32({ $0.hasPackage_p }, fieldNumber: 466),
+    .singularInt32({ $0.hasPacked_p }, fieldNumber: 467),
+    .singularInt32({ $0.hasPhpClassPrefix_p }, fieldNumber: 468),
+    .singularInt32({ $0.hasPhpGenericServices_p }, fieldNumber: 469),
+    .singularInt32({ $0.hasPhpMetadataNamespace_p }, fieldNumber: 470),
+    .singularInt32({ $0.hasPhpNamespace_p }, fieldNumber: 471),
+    .singularInt32({ $0.hasPositiveIntValue_p }, fieldNumber: 472),
+    .singularInt32({ $0.hasProto3Optional_p }, fieldNumber: 473),
+    .singularInt32({ $0.hasPyGenericServices_p }, fieldNumber: 474),
+    .singularInt32({ $0.hasRepeated_p }, fieldNumber: 475),
+    .singularInt32({ $0.hasRepeatedFieldEncoding_p }, fieldNumber: 476),
+    .singularInt32({ $0.hasReserved_p }, fieldNumber: 477),
+    .singularInt32({ $0.hasRetention_p }, fieldNumber: 478),
+    .singularInt32({ $0.hasRubyPackage_p }, fieldNumber: 479),
+    .singularInt32({ $0.hasSemantic_p }, fieldNumber: 480),
+    .singularInt32({ $0.hasServerStreaming_p }, fieldNumber: 481),
+    .singularInt32({ $0.hasSourceCodeInfo_p }, fieldNumber: 482),
+    .singularInt32({ $0.hasSourceContext_p }, fieldNumber: 483),
+    .singularInt32({ $0.hasSourceFile_p }, fieldNumber: 484),
+    .singularInt32({ $0.hasStart_p }, fieldNumber: 485),
+    .singularInt32({ $0.hasStringValue_p }, fieldNumber: 486),
+    .singularInt32({ $0.hasSwiftPrefix_p }, fieldNumber: 487),
+    .singularInt32({ $0.hasSyntax_p }, fieldNumber: 488),
+    .singularInt32({ $0.hasTrailingComments_p }, fieldNumber: 489),
+    .singularInt32({ $0.hasType_p }, fieldNumber: 490),
+    .singularInt32({ $0.hasTypeName_p }, fieldNumber: 491),
+    .singularInt32({ $0.hasUnverifiedLazy_p }, fieldNumber: 492),
+    .singularInt32({ $0.hasUtf8Validation_p }, fieldNumber: 493),
+    .singularInt32({ $0.hasValue_p }, fieldNumber: 494),
+    .singularInt32({ $0.hasVerification_p }, fieldNumber: 495),
+    .singularInt32({ $0.hasWeak_p }, fieldNumber: 496),
+    .singularInt32({ $0.hour }, fieldNumber: 497),
+    .singularInt32({ $0.i }, fieldNumber: 498),
+    .singularInt32({ $0.idempotencyLevel }, fieldNumber: 499),
+    .singularInt32({ $0.identifierValue }, fieldNumber: 500),
+    .singularInt32({ $0.`if` }, fieldNumber: 501),
+    .singularInt32({ $0.ignoreUnknownFields }, fieldNumber: 502),
+    .singularInt32({ $0.index }, fieldNumber: 503),
+    .singularInt32({ $0.init_p }, fieldNumber: 504),
+    .singularInt32({ $0.`inout` }, fieldNumber: 505),
+    .singularInt32({ $0.inputType }, fieldNumber: 506),
+    .singularInt32({ $0.insert }, fieldNumber: 507),
+    .singularInt32({ $0.int }, fieldNumber: 508),
+    .singularInt32({ $0.int32 }, fieldNumber: 509),
+    .singularInt32({ $0.int32Value }, fieldNumber: 510),
+    .singularInt32({ $0.int64 }, fieldNumber: 511),
+    .singularInt32({ $0.int64Value }, fieldNumber: 512),
+    .singularInt32({ $0.int8 }, fieldNumber: 513),
+    .singularInt32({ $0.integerLiteral }, fieldNumber: 514),
+    .singularInt32({ $0.integerLiteralType }, fieldNumber: 515),
+    .singularInt32({ $0.intern }, fieldNumber: 516),
+    .singularInt32({ $0.`internal` }, fieldNumber: 517),
+    .singularInt32({ $0.internalState }, fieldNumber: 518),
+    .singularInt32({ $0.into }, fieldNumber: 519),
+    .singularInt32({ $0.ints }, fieldNumber: 520),
+    .singularInt32({ $0.isA }, fieldNumber: 521),
+    .singularInt32({ $0.isEqual }, fieldNumber: 522),
+    .singularInt32({ $0.isEqualTo }, fieldNumber: 523),
+    .singularInt32({ $0.isExtension }, fieldNumber: 524),
+    .singularInt32({ $0.isInitialized_p }, fieldNumber: 525),
+    .singularInt32({ $0.isNegative }, fieldNumber: 526),
+    .singularInt32({ $0.isUnset }, fieldNumber: 527),
+    .singularInt32({ $0.itemTagsEncodedSize }, fieldNumber: 528),
+    .singularInt32({ $0.iterator }, fieldNumber: 529),
+    .singularInt32({ $0.javaGenerateEqualsAndHash }, fieldNumber: 530),
+    .singularInt32({ $0.javaGenericServices }, fieldNumber: 531),
+    .singularInt32({ $0.javaMultipleFiles }, fieldNumber: 532),
+    .singularInt32({ $0.javaOuterClassname }, fieldNumber: 533),
+    .singularInt32({ $0.javaPackage }, fieldNumber: 534),
+    .singularInt32({ $0.javaStringCheckUtf8 }, fieldNumber: 535),
+    .singularInt32({ $0.jsondecoder }, fieldNumber: 536),
+    .singularInt32({ $0.jsondecodingError }, fieldNumber: 537),
+    .singularInt32({ $0.jsondecodingOptions }, fieldNumber: 538),
+    .singularInt32({ $0.jsonEncoder }, fieldNumber: 539),
+    .singularInt32({ $0.jsonencodingError }, fieldNumber: 540),
+    .singularInt32({ $0.jsonencodingOptions }, fieldNumber: 541),
+    .singularInt32({ $0.jsonencodingVisitor }, fieldNumber: 542),
+    .singularInt32({ $0.jsonFormat }, fieldNumber: 543),
+    .singularInt32({ $0.jsonmapEncodingVisitor }, fieldNumber: 544),
+    .singularInt32({ $0.jsonName }, fieldNumber: 545),
+    .singularInt32({ $0.jsonPath }, fieldNumber: 546),
+    .singularInt32({ $0.jsonPaths }, fieldNumber: 547),
+    .singularInt32({ $0.jsonscanner }, fieldNumber: 548),
+    .singularInt32({ $0.jsonString }, fieldNumber: 549),
+    .singularInt32({ $0.jsonText }, fieldNumber: 550),
+    .singularInt32({ $0.jsonUtf8Bytes }, fieldNumber: 551),
+    .singularInt32({ $0.jsonUtf8Data }, fieldNumber: 552),
+    .singularInt32({ $0.jstype }, fieldNumber: 553),
+    .singularInt32({ $0.k }, fieldNumber: 554),
+    .singularInt32({ $0.kChunkSize }, fieldNumber: 555),
+    .singularInt32({ $0.key }, fieldNumber: 556),
+    .singularInt32({ $0.keyField }, fieldNumber: 557),
+    .singularInt32({ $0.keyFieldOpt }, fieldNumber: 558),
+    .singularInt32({ $0.keyType }, fieldNumber: 559),
+    .singularInt32({ $0.kind }, fieldNumber: 560),
+    .singularInt32({ $0.l }, fieldNumber: 561),
+    .singularInt32({ $0.label }, fieldNumber: 562),
+    .singularInt32({ $0.lazy }, fieldNumber: 563),
+    .singularInt32({ $0.leadingComments }, fieldNumber: 564),
+    .singularInt32({ $0.leadingDetachedComments }, fieldNumber: 565),
+    .singularInt32({ $0.length }, fieldNumber: 566),
+    .singularInt32({ $0.lessThan }, fieldNumber: 567),
+    .singularInt32({ $0.`let` }, fieldNumber: 568),
+    .singularInt32({ $0.lhs }, fieldNumber: 569),
+    .singularInt32({ $0.list }, fieldNumber: 570),
+    .singularInt32({ $0.listOfMessages }, fieldNumber: 571),
+    .singularInt32({ $0.listValue }, fieldNumber: 572),
+    .singularInt32({ $0.littleEndian }, fieldNumber: 573),
+    .singularInt32({ $0.littleEndianBytes }, fieldNumber: 574),
+    .singularInt32({ $0.load }, fieldNumber: 575),
+    .singularInt32({ $0.localHasher }, fieldNumber: 576),
+    .singularInt32({ $0.location }, fieldNumber: 577),
+    .singularInt32({ $0.m }, fieldNumber: 578),
+    .singularInt32({ $0.major }, fieldNumber: 579),
+    .singularInt32({ $0.makeAsyncIterator }, fieldNumber: 580),
+    .singularInt32({ $0.makeIterator }, fieldNumber: 581),
+    .singularInt32({ $0.map }, fieldNumber: 582),
+    .singularInt32({ $0.mapEntry }, fieldNumber: 583),
+    .singularInt32({ $0.mapKeyType }, fieldNumber: 584),
+    .singularInt32({ $0.mapToMessages }, fieldNumber: 585),
+    .singularInt32({ $0.mapValueType }, fieldNumber: 586),
+    .singularInt32({ $0.mapVisitor }, fieldNumber: 587),
+    .singularInt32({ $0.maximumEdition }, fieldNumber: 588),
+    .singularInt32({ $0.mdayStart }, fieldNumber: 589),
+    .singularInt32({ $0.merge }, fieldNumber: 590),
+    .singularInt32({ $0.message }, fieldNumber: 591),
+    .singularInt32({ $0.messageDepthLimit }, fieldNumber: 592),
+    .singularInt32({ $0.messageEncoding }, fieldNumber: 593),
+    .singularInt32({ $0.messageExtension }, fieldNumber: 594),
+    .singularInt32({ $0.messageImplementationBase }, fieldNumber: 595),
+    .singularInt32({ $0.messageOptions }, fieldNumber: 596),
+    .singularInt32({ $0.messageSet }, fieldNumber: 597),
+    .singularInt32({ $0.messageSetWireFormat }, fieldNumber: 598),
+    .singularInt32({ $0.messageSize }, fieldNumber: 599),
+    .singularInt32({ $0.messageType }, fieldNumber: 600),
+    .singularInt32({ $0.method }, fieldNumber: 601),
+    .singularInt32({ $0.methodDescriptorProto }, fieldNumber: 602),
+    .singularInt32({ $0.methodOptions }, fieldNumber: 603),
+    .singularInt32({ $0.methods }, fieldNumber: 604),
+    .singularInt32({ $0.min }, fieldNumber: 605),
+    .singularInt32({ $0.minimumEdition }, fieldNumber: 606),
+    .singularInt32({ $0.minor }, fieldNumber: 607),
+    .singularInt32({ $0.mixin }, fieldNumber: 608),
+    .singularInt32({ $0.mixins }, fieldNumber: 609),
+    .singularInt32({ $0.modifier }, fieldNumber: 610),
+    .singularInt32({ $0.modify }, fieldNumber: 611),
+    .singularInt32({ $0.month }, fieldNumber: 612),
+    .singularInt32({ $0.msgExtension }, fieldNumber: 613),
+    .singularInt32({ $0.mutating }, fieldNumber: 614),
+    .singularInt32({ $0.n }, fieldNumber: 615),
+    .singularInt32({ $0.name }, fieldNumber: 616),
+    .singularInt32({ $0.nameDescription }, fieldNumber: 617),
+    .singularInt32({ $0.nameMap }, fieldNumber: 618),
+    .singularInt32({ $0.namePart }, fieldNumber: 619),
+    .singularInt32({ $0.names }, fieldNumber: 620),
+    .singularInt32({ $0.nanos }, fieldNumber: 621),
+    .singularInt32({ $0.negativeIntValue }, fieldNumber: 622),
+    .singularInt32({ $0.nestedType }, fieldNumber: 623),
+    .singularInt32({ $0.newL }, fieldNumber: 624),
+    .singularInt32({ $0.newList }, fieldNumber: 625),
+    .singularInt32({ $0.newValue }, fieldNumber: 626),
+    .singularInt32({ $0.next }, fieldNumber: 627),
+    .singularInt32({ $0.nextByte }, fieldNumber: 628),
+    .singularInt32({ $0.nextFieldNumber }, fieldNumber: 629),
+    .singularInt32({ $0.nextVarInt }, fieldNumber: 630),
+    .singularInt32({ $0.`nil` }, fieldNumber: 631),
+    .singularInt32({ $0.nilLiteral }, fieldNumber: 632),
+    .singularInt32({ $0.noStandardDescriptorAccessor }, fieldNumber: 633),
+    .singularInt32({ $0.nullValue }, fieldNumber: 634),
+    .singularInt32({ $0.number }, fieldNumber: 635),
+    .singularInt32({ $0.numberValue }, fieldNumber: 636),
+    .singularInt32({ $0.objcClassPrefix }, fieldNumber: 637),
+    .singularInt32({ $0.of }, fieldNumber: 638),
+    .singularInt32({ $0.oneOf }, fieldNumber: 639),
+    .singularInt32({ $0.oneofDecl }, fieldNumber: 640),
+    .singularInt32({ $0.oneofDescriptorProto }, fieldNumber: 641),
+    .singularInt32({ $0.oneofIndex }, fieldNumber: 642),
+    .singularInt32({ $0.oneofOptions }, fieldNumber: 643),
+    .singularInt32({ $0.oneofs }, fieldNumber: 644),
+    .singularInt32({ $0.oneOfKind }, fieldNumber: 645),
+    .singularInt32({ $0.optimizeFor }, fieldNumber: 646),
+    .singularInt32({ $0.optimizeMode }, fieldNumber: 647),
+    .singularInt32({ $0.option }, fieldNumber: 648),
+    .singularInt32({ $0.optionalEnumExtensionField }, fieldNumber: 649),
+    .singularInt32({ $0.optionalExtensionField }, fieldNumber: 650),
+    .singularInt32({ $0.optionalGroupExtensionField }, fieldNumber: 651),
+    .singularInt32({ $0.optionalMessageExtensionField }, fieldNumber: 652),
+    .singularInt32({ $0.optionRetention }, fieldNumber: 653),
+    .singularInt32({ $0.options }, fieldNumber: 654),
+    .singularInt32({ $0.optionTargetType }, fieldNumber: 655),
+    .singularInt32({ $0.other }, fieldNumber: 656),
+    .singularInt32({ $0.others }, fieldNumber: 657),
+    .singularInt32({ $0.out }, fieldNumber: 658),
+    .singularInt32({ $0.outputType }, fieldNumber: 659),
+    .singularInt32({ $0.p }, fieldNumber: 660),
+    .singularInt32({ $0.package }, fieldNumber: 661),
+    .singularInt32({ $0.packed }, fieldNumber: 662),
+    .singularInt32({ $0.packedBool }, fieldNumber: 663),
+    .singularInt32({ $0.packedDouble }, fieldNumber: 664),
+    .singularInt32({ $0.packedEnum }, fieldNumber: 665),
+    .singularInt32({ $0.packedEnumExtensionField }, fieldNumber: 666),
+    .singularInt32({ $0.packedExtensionField }, fieldNumber: 667),
+    .singularInt32({ $0.packedFixed32 }, fieldNumber: 668),
+    .singularInt32({ $0.packedFixed64 }, fieldNumber: 669),
+    .singularInt32({ $0.packedFloat }, fieldNumber: 670),
+    .singularInt32({ $0.packedInt32 }, fieldNumber: 671),
+    .singularInt32({ $0.packedInt64 }, fieldNumber: 672),
+    .singularInt32({ $0.packedSfixed32 }, fieldNumber: 673),
+    .singularInt32({ $0.packedSfixed64 }, fieldNumber: 674),
+    .singularInt32({ $0.packedSint32 }, fieldNumber: 675),
+    .singularInt32({ $0.packedSint64 }, fieldNumber: 676),
+    .singularInt32({ $0.packedUint32 }, fieldNumber: 677),
+    .singularInt32({ $0.packedUint64 }, fieldNumber: 678),
+    .singularInt32({ $0.padding }, fieldNumber: 679),
+    .singularInt32({ $0.parent }, fieldNumber: 680),
+    .singularInt32({ $0.parse }, fieldNumber: 681),
+    .singularInt32({ $0.path }, fieldNumber: 682),
+    .singularInt32({ $0.paths }, fieldNumber: 683),
+    .singularInt32({ $0.payload }, fieldNumber: 684),
+    .singularInt32({ $0.payloadSize }, fieldNumber: 685),
+    .singularInt32({ $0.phpClassPrefix }, fieldNumber: 686),
+    .singularInt32({ $0.phpGenericServices }, fieldNumber: 687),
+    .singularInt32({ $0.phpMetadataNamespace }, fieldNumber: 688),
+    .singularInt32({ $0.phpNamespace }, fieldNumber: 689),
+    .singularInt32({ $0.pos }, fieldNumber: 690),
+    .singularInt32({ $0.positiveIntValue }, fieldNumber: 691),
+    .singularInt32({ $0.prefix }, fieldNumber: 692),
+    .singularInt32({ $0.preserveProtoFieldNames }, fieldNumber: 693),
+    .singularInt32({ $0.preTraverse }, fieldNumber: 694),
+    .singularInt32({ $0.printUnknownFields }, fieldNumber: 695),
+    .singularInt32({ $0.proto2 }, fieldNumber: 696),
+    .singularInt32({ $0.proto3DefaultValue }, fieldNumber: 697),
+    .singularInt32({ $0.proto3Optional }, fieldNumber: 698),
+    .singularInt32({ $0.protobufApiversionCheck }, fieldNumber: 699),
+    .singularInt32({ $0.protobufApiversion3 }, fieldNumber: 700),
+    .singularInt32({ $0.protobufBool }, fieldNumber: 701),
+    .singularInt32({ $0.protobufBytes }, fieldNumber: 702),
+    .singularInt32({ $0.protobufDouble }, fieldNumber: 703),
+    .singularInt32({ $0.protobufEnumMap }, fieldNumber: 704),
+    .singularInt32({ $0.protobufExtension }, fieldNumber: 705),
+    .singularInt32({ $0.protobufFixed32 }, fieldNumber: 706),
+    .singularInt32({ $0.protobufFixed64 }, fieldNumber: 707),
+    .singularInt32({ $0.protobufFloat }, fieldNumber: 708),
+    .singularInt32({ $0.protobufInt32 }, fieldNumber: 709),
+    .singularInt32({ $0.protobufInt64 }, fieldNumber: 710),
+    .singularInt32({ $0.protobufMap }, fieldNumber: 711),
+    .singularInt32({ $0.protobufMessageMap }, fieldNumber: 712),
+    .singularInt32({ $0.protobufSfixed32 }, fieldNumber: 713),
+    .singularInt32({ $0.protobufSfixed64 }, fieldNumber: 714),
+    .singularInt32({ $0.protobufSint32 }, fieldNumber: 715),
+    .singularInt32({ $0.protobufSint64 }, fieldNumber: 716),
+    .singularInt32({ $0.protobufString }, fieldNumber: 717),
+    .singularInt32({ $0.protobufUint32 }, fieldNumber: 718),
+    .singularInt32({ $0.protobufUint64 }, fieldNumber: 719),
+    .singularInt32({ $0.protobufExtensionFieldValues }, fieldNumber: 720),
+    .singularInt32({ $0.protobufFieldNumber }, fieldNumber: 721),
+    .singularInt32({ $0.protobufGeneratedIsEqualTo }, fieldNumber: 722),
+    .singularInt32({ $0.protobufNameMap }, fieldNumber: 723),
+    .singularInt32({ $0.protobufNewField }, fieldNumber: 724),
+    .singularInt32({ $0.protobufPackage }, fieldNumber: 725),
+    .singularInt32({ $0.`protocol` }, fieldNumber: 726),
+    .singularInt32({ $0.protoFieldName }, fieldNumber: 727),
+    .singularInt32({ $0.protoMessageName }, fieldNumber: 728),
+    .singularInt32({ $0.protoNameProviding }, fieldNumber: 729),
+    .singularInt32({ $0.protoPaths }, fieldNumber: 730),
+    .singularInt32({ $0.`public` }, fieldNumber: 731),
+    .singularInt32({ $0.publicDependency }, fieldNumber: 732),
+    .singularInt32({ $0.putBoolValue }, fieldNumber: 733),
+    .singularInt32({ $0.putBytesValue }, fieldNumber: 734),
+    .singularInt32({ $0.putDoubleValue }, fieldNumber: 735),
+    .singularInt32({ $0.putEnumValue }, fieldNumber: 736),
+    .singularInt32({ $0.putFixedUint32 }, fieldNumber: 737),
+    .singularInt32({ $0.putFixedUint64 }, fieldNumber: 738),
+    .singularInt32({ $0.putFloatValue }, fieldNumber: 739),
+    .singularInt32({ $0.putInt64 }, fieldNumber: 740),
+    .singularInt32({ $0.putStringValue }, fieldNumber: 741),
+    .singularInt32({ $0.putUint64 }, fieldNumber: 742),
+    .singularInt32({ $0.putUint64Hex }, fieldNumber: 743),
+    .singularInt32({ $0.putVarInt }, fieldNumber: 744),
+    .singularInt32({ $0.putZigZagVarInt }, fieldNumber: 745),
+    .singularInt32({ $0.pyGenericServices }, fieldNumber: 746),
+    .singularInt32({ $0.r }, fieldNumber: 747),
+    .singularInt32({ $0.rawChars }, fieldNumber: 748),
+    .singularInt32({ $0.rawRepresentable }, fieldNumber: 749),
+    .singularInt32({ $0.rawValue }, fieldNumber: 750),
+    .singularInt32({ $0.read4HexDigits }, fieldNumber: 751),
+    .singularInt32({ $0.readBytes }, fieldNumber: 752),
+    .singularInt32({ $0.register }, fieldNumber: 753),
+    .singularInt32({ $0.repeated }, fieldNumber: 754),
+    .singularInt32({ $0.repeatedBool }, fieldNumber: 755),
+    .singularInt32({ $0.repeatedBytes }, fieldNumber: 756),
+    .singularInt32({ $0.repeatedDouble }, fieldNumber: 757),
+    .singularInt32({ $0.repeatedEnum }, fieldNumber: 758),
+    .singularInt32({ $0.repeatedEnumExtensionField }, fieldNumber: 759),
+    .singularInt32({ $0.repeatedExtensionField }, fieldNumber: 760),
+    .singularInt32({ $0.repeatedFieldEncoding }, fieldNumber: 761),
+    .singularInt32({ $0.repeatedFixed32 }, fieldNumber: 762),
+    .singularInt32({ $0.repeatedFixed64 }, fieldNumber: 763),
+    .singularInt32({ $0.repeatedFloat }, fieldNumber: 764),
+    .singularInt32({ $0.repeatedGroup }, fieldNumber: 765),
+    .singularInt32({ $0.repeatedGroupExtensionField }, fieldNumber: 766),
+    .singularInt32({ $0.repeatedInt32 }, fieldNumber: 767),
+    .singularInt32({ $0.repeatedInt64 }, fieldNumber: 768),
+    .singularInt32({ $0.repeatedMessage }, fieldNumber: 769),
+    .singularInt32({ $0.repeatedMessageExtensionField }, fieldNumber: 770),
+    .singularInt32({ $0.repeatedSfixed32 }, fieldNumber: 771),
+    .singularInt32({ $0.repeatedSfixed64 }, fieldNumber: 772),
+    .singularInt32({ $0.repeatedSint32 }, fieldNumber: 773),
+    .singularInt32({ $0.repeatedSint64 }, fieldNumber: 774),
+    .singularInt32({ $0.repeatedString }, fieldNumber: 775),
+    .singularInt32({ $0.repeatedUint32 }, fieldNumber: 776),
+    .singularInt32({ $0.repeatedUint64 }, fieldNumber: 777),
+    .singularInt32({ $0.repeating }, fieldNumber: 778),
+    .singularInt32({ $0.requestStreaming }, fieldNumber: 779),
+    .singularInt32({ $0.requestTypeURL }, fieldNumber: 780),
+    .singularInt32({ $0.requiredSize }, fieldNumber: 781),
+    .singularInt32({ $0.responseStreaming }, fieldNumber: 782),
+    .singularInt32({ $0.responseTypeURL }, fieldNumber: 783),
+    .singularInt32({ $0.result }, fieldNumber: 784),
+    .singularInt32({ $0.retention }, fieldNumber: 785),
+    .singularInt32({ $0.`rethrows` }, fieldNumber: 786),
+    .singularInt32({ $0.`return` }, fieldNumber: 787),
+    .singularInt32({ $0.returnType }, fieldNumber: 788),
+    .singularInt32({ $0.revision }, fieldNumber: 789),
+    .singularInt32({ $0.rhs }, fieldNumber: 790),
+    .singularInt32({ $0.root }, fieldNumber: 791),
+    .singularInt32({ $0.rubyPackage }, fieldNumber: 792),
+    .singularInt32({ $0.s }, fieldNumber: 793),
+    .singularInt32({ $0.sawBackslash }, fieldNumber: 794),
+    .singularInt32({ $0.sawSection4Characters }, fieldNumber: 795),
+    .singularInt32({ $0.sawSection5Characters }, fieldNumber: 796),
+    .singularInt32({ $0.scanner }, fieldNumber: 797),
+    .singularInt32({ $0.seconds }, fieldNumber: 798),
+    .singularInt32({ $0.self_p }, fieldNumber: 799),
+    .singularInt32({ $0.semantic }, fieldNumber: 800),
+    .singularInt32({ $0.sendable }, fieldNumber: 801),
+    .singularInt32({ $0.separator }, fieldNumber: 802),
+    .singularInt32({ $0.serialize }, fieldNumber: 803),
+    .singularInt32({ $0.serializedBytes }, fieldNumber: 804),
+    .singularInt32({ $0.serializedData }, fieldNumber: 805),
+    .singularInt32({ $0.serializedSize }, fieldNumber: 806),
+    .singularInt32({ $0.serverStreaming }, fieldNumber: 807),
+    .singularInt32({ $0.service }, fieldNumber: 808),
+    .singularInt32({ $0.serviceDescriptorProto }, fieldNumber: 809),
+    .singularInt32({ $0.serviceOptions }, fieldNumber: 810),
+    .singularInt32({ $0.set }, fieldNumber: 811),
+    .singularInt32({ $0.setExtensionValue }, fieldNumber: 812),
+    .singularInt32({ $0.shift }, fieldNumber: 813),
+    .singularInt32({ $0.simpleExtensionMap }, fieldNumber: 814),
+    .singularInt32({ $0.singularBool }, fieldNumber: 815),
+    .singularInt32({ $0.singularBytes }, fieldNumber: 816),
+    .singularInt32({ $0.singularDouble }, fieldNumber: 817),
+    .singularInt32({ $0.singularEnum }, fieldNumber: 818),
+    .singularInt32({ $0.singularFixed32 }, fieldNumber: 819),
+    .singularInt32({ $0.singularFixed64 }, fieldNumber: 820),
+    .singularInt32({ $0.singularFloat }, fieldNumber: 821),
+    .singularInt32({ $0.singularGroup }, fieldNumber: 822),
+    .singularInt32({ $0.singularInt32 }, fieldNumber: 823),
+    .singularInt32({ $0.singularInt64 }, fieldNumber: 824),
+    .singularInt32({ $0.singularMessage }, fieldNumber: 825),
+    .singularInt32({ $0.singularSfixed32 }, fieldNumber: 826),
+    .singularInt32({ $0.singularSfixed64 }, fieldNumber: 827),
+    .singularInt32({ $0.singularSint32 }, fieldNumber: 828),
+    .singularInt32({ $0.singularSint64 }, fieldNumber: 829),
+    .singularInt32({ $0.singularString }, fieldNumber: 830),
+    .singularInt32({ $0.singularUint32 }, fieldNumber: 831),
+    .singularInt32({ $0.singularUint64 }, fieldNumber: 832),
+    .singularInt32({ $0.size }, fieldNumber: 833),
+    .singularInt32({ $0.sizer }, fieldNumber: 834),
+    .singularInt32({ $0.source }, fieldNumber: 835),
+    .singularInt32({ $0.sourceCodeInfo }, fieldNumber: 836),
+    .singularInt32({ $0.sourceContext }, fieldNumber: 837),
+    .singularInt32({ $0.sourceEncoding }, fieldNumber: 838),
+    .singularInt32({ $0.sourceFile }, fieldNumber: 839),
+    .singularInt32({ $0.span }, fieldNumber: 840),
+    .singularInt32({ $0.split }, fieldNumber: 841),
+    .singularInt32({ $0.start }, fieldNumber: 842),
+    .singularInt32({ $0.startArray }, fieldNumber: 843),
+    .singularInt32({ $0.startArrayObject }, fieldNumber: 844),
+    .singularInt32({ $0.startField }, fieldNumber: 845),
+    .singularInt32({ $0.startIndex }, fieldNumber: 846),
+    .singularInt32({ $0.startMessageField }, fieldNumber: 847),
+    .singularInt32({ $0.startObject }, fieldNumber: 848),
+    .singularInt32({ $0.startRegularField }, fieldNumber: 849),
+    .singularInt32({ $0.state }, fieldNumber: 850),
+    .singularInt32({ $0.`static` }, fieldNumber: 851),
+    .singularInt32({ $0.staticString }, fieldNumber: 852),
+    .singularInt32({ $0.storage }, fieldNumber: 853),
+    .singularInt32({ $0.string }, fieldNumber: 854),
+    .singularInt32({ $0.stringLiteral }, fieldNumber: 855),
+    .singularInt32({ $0.stringLiteralType }, fieldNumber: 856),
+    .singularInt32({ $0.stringResult }, fieldNumber: 857),
+    .singularInt32({ $0.stringValue }, fieldNumber: 858),
+    .singularInt32({ $0.`struct` }, fieldNumber: 859),
+    .singularInt32({ $0.structValue }, fieldNumber: 860),
+    .singularInt32({ $0.subDecoder }, fieldNumber: 861),
+    .singularInt32({ $0.`subscript` }, fieldNumber: 862),
+    .singularInt32({ $0.subVisitor }, fieldNumber: 863),
+    .singularInt32({ $0.swift }, fieldNumber: 864),
+    .singularInt32({ $0.swiftPrefix }, fieldNumber: 865),
+    .singularInt32({ $0.swiftProtobufContiguousBytes }, fieldNumber: 866),
+    .singularInt32({ $0.syntax }, fieldNumber: 867),
+    .singularInt32({ $0.t }, fieldNumber: 868),
+    .singularInt32({ $0.tag }, fieldNumber: 869),
+    .singularInt32({ $0.targets }, fieldNumber: 870),
+    .singularInt32({ $0.terminator }, fieldNumber: 871),
+    .singularInt32({ $0.testDecoder }, fieldNumber: 872),
+    .singularInt32({ $0.text }, fieldNumber: 873),
+    .singularInt32({ $0.textDecoder }, fieldNumber: 874),
+    .singularInt32({ $0.textFormatDecoder }, fieldNumber: 875),
+    .singularInt32({ $0.textFormatDecodingError }, fieldNumber: 876),
+    .singularInt32({ $0.textFormatDecodingOptions }, fieldNumber: 877),
+    .singularInt32({ $0.textFormatEncodingOptions }, fieldNumber: 878),
+    .singularInt32({ $0.textFormatEncodingVisitor }, fieldNumber: 879),
+    .singularInt32({ $0.textFormatString }, fieldNumber: 880),
+    .singularInt32({ $0.throwOrIgnore }, fieldNumber: 881),
+    .singularInt32({ $0.`throws` }, fieldNumber: 882),
+    .singularInt32({ $0.timeInterval }, fieldNumber: 883),
+    .singularInt32({ $0.timeIntervalSince1970 }, fieldNumber: 884),
+    .singularInt32({ $0.timeIntervalSinceReferenceDate }, fieldNumber: 885),
+    .singularInt32({ $0.timestamp }, fieldNumber: 886),
+    .singularInt32({ $0.toConcrete }, fieldNumber: 887),
+    .singularInt32({ $0.total }, fieldNumber: 888),
+    .singularInt32({ $0.totalArrayDepth }, fieldNumber: 889),
+    .singularInt32({ $0.totalSize }, fieldNumber: 890),
+    .singularInt32({ $0.trailingComments }, fieldNumber: 891),
+    .singularInt32({ $0.traverse }, fieldNumber: 892),
+    .singularInt32({ $0.`true` }, fieldNumber: 893),
+    .singularInt32({ $0.`try` }, fieldNumber: 894),
+    .singularInt32({ $0.type }, fieldNumber: 895),
+    .singularInt32({ $0.`typealias` }, fieldNumber: 896),
+    .singularInt32({ $0.typeEnum }, fieldNumber: 897),
+    .singularInt32({ $0.typeName }, fieldNumber: 898),
+    .singularInt32({ $0.typePrefix }, fieldNumber: 899),
+    .singularInt32({ $0.typeStart }, fieldNumber: 900),
+    .singularInt32({ $0.typeUnknown }, fieldNumber: 901),
+    .singularInt32({ $0.typeURL }, fieldNumber: 902),
+    .singularInt32({ $0.uint32 }, fieldNumber: 903),
+    .singularInt32({ $0.uint32Value }, fieldNumber: 904),
+    .singularInt32({ $0.uint64 }, fieldNumber: 905),
+    .singularInt32({ $0.uint64Value }, fieldNumber: 906),
+    .singularInt32({ $0.uint8 }, fieldNumber: 907),
+    .singularInt32({ $0.unchecked }, fieldNumber: 908),
+    .singularInt32({ $0.unicodeScalarLiteral }, fieldNumber: 909),
+    .singularInt32({ $0.unicodeScalarLiteralType }, fieldNumber: 910),
+    .singularInt32({ $0.unicodeScalars }, fieldNumber: 911),
+    .singularInt32({ $0.unicodeScalarView }, fieldNumber: 912),
+    .singularInt32({ $0.uninterpretedOption }, fieldNumber: 913),
+    .singularInt32({ $0.union }, fieldNumber: 914),
+    .singularInt32({ $0.uniqueStorage }, fieldNumber: 915),
+    .singularInt32({ $0.unknown }, fieldNumber: 916),
+    .singularInt32({ $0.unknownFields_p }, fieldNumber: 917),
+    .singularInt32({ $0.unknownStorage }, fieldNumber: 918),
+    .singularInt32({ $0.unpackTo }, fieldNumber: 919),
+    .singularInt32({ $0.unsafeBufferPointer }, fieldNumber: 920),
+    .singularInt32({ $0.unsafeMutablePointer }, fieldNumber: 921),
+    .singularInt32({ $0.unsafeMutableRawBufferPointer }, fieldNumber: 922),
+    .singularInt32({ $0.unsafeRawBufferPointer }, fieldNumber: 923),
+    .singularInt32({ $0.unsafeRawPointer }, fieldNumber: 924),
+    .singularInt32({ $0.unverifiedLazy }, fieldNumber: 925),
+    .singularInt32({ $0.updatedOptions }, fieldNumber: 926),
+    .singularInt32({ $0.url }, fieldNumber: 927),
+    .singularInt32({ $0.useDeterministicOrdering }, fieldNumber: 928),
+    .singularInt32({ $0.utf8 }, fieldNumber: 929),
+    .singularInt32({ $0.utf8Ptr }, fieldNumber: 930),
+    .singularInt32({ $0.utf8ToDouble }, fieldNumber: 931),
+    .singularInt32({ $0.utf8Validation }, fieldNumber: 932),
+    .singularInt32({ $0.utf8View }, fieldNumber: 933),
+    .singularInt32({ $0.v }, fieldNumber: 934),
+    .singularInt32({ $0.value }, fieldNumber: 935),
+    .singularInt32({ $0.valueField }, fieldNumber: 936),
+    .singularInt32({ $0.values }, fieldNumber: 937),
+    .singularInt32({ $0.valueType }, fieldNumber: 938),
+    .singularInt32({ $0.`var` }, fieldNumber: 939),
+    .singularInt32({ $0.verification }, fieldNumber: 940),
+    .singularInt32({ $0.verificationState }, fieldNumber: 941),
+    .singularInt32({ $0.version }, fieldNumber: 942),
+    .singularInt32({ $0.versionString }, fieldNumber: 943),
+    .singularInt32({ $0.visitExtensionFields }, fieldNumber: 944),
+    .singularInt32({ $0.visitExtensionFieldsAsMessageSet }, fieldNumber: 945),
+    .singularInt32({ $0.visitMapField }, fieldNumber: 946),
+    .singularInt32({ $0.visitor }, fieldNumber: 947),
+    .singularInt32({ $0.visitPacked }, fieldNumber: 948),
+    .singularInt32({ $0.visitPackedBoolField }, fieldNumber: 949),
+    .singularInt32({ $0.visitPackedDoubleField }, fieldNumber: 950),
+    .singularInt32({ $0.visitPackedEnumField }, fieldNumber: 951),
+    .singularInt32({ $0.visitPackedFixed32Field }, fieldNumber: 952),
+    .singularInt32({ $0.visitPackedFixed64Field }, fieldNumber: 953),
+    .singularInt32({ $0.visitPackedFloatField }, fieldNumber: 954),
+    .singularInt32({ $0.visitPackedInt32Field }, fieldNumber: 955),
+    .singularInt32({ $0.visitPackedInt64Field }, fieldNumber: 956),
+    .singularInt32({ $0.visitPackedSfixed32Field }, fieldNumber: 957),
+    .singularInt32({ $0.visitPackedSfixed64Field }, fieldNumber: 958),
+    .singularInt32({ $0.visitPackedSint32Field }, fieldNumber: 959),
+    .singularInt32({ $0.visitPackedSint64Field }, fieldNumber: 960),
+    .singularInt32({ $0.visitPackedUint32Field }, fieldNumber: 961),
+    .singularInt32({ $0.visitPackedUint64Field }, fieldNumber: 962),
+    .singularInt32({ $0.visitRepeated }, fieldNumber: 963),
+    .singularInt32({ $0.visitRepeatedBoolField }, fieldNumber: 964),
+    .singularInt32({ $0.visitRepeatedBytesField }, fieldNumber: 965),
+    .singularInt32({ $0.visitRepeatedDoubleField }, fieldNumber: 966),
+    .singularInt32({ $0.visitRepeatedEnumField }, fieldNumber: 967),
+    .singularInt32({ $0.visitRepeatedFixed32Field }, fieldNumber: 968),
+    .singularInt32({ $0.visitRepeatedFixed64Field }, fieldNumber: 969),
+    .singularInt32({ $0.visitRepeatedFloatField }, fieldNumber: 970),
+    .singularInt32({ $0.visitRepeatedGroupField }, fieldNumber: 971),
+    .singularInt32({ $0.visitRepeatedInt32Field }, fieldNumber: 972),
+    .singularInt32({ $0.visitRepeatedInt64Field }, fieldNumber: 973),
+    .singularInt32({ $0.visitRepeatedMessageField }, fieldNumber: 974),
+    .singularInt32({ $0.visitRepeatedSfixed32Field }, fieldNumber: 975),
+    .singularInt32({ $0.visitRepeatedSfixed64Field }, fieldNumber: 976),
+    .singularInt32({ $0.visitRepeatedSint32Field }, fieldNumber: 977),
+    .singularInt32({ $0.visitRepeatedSint64Field }, fieldNumber: 978),
+    .singularInt32({ $0.visitRepeatedStringField }, fieldNumber: 979),
+    .singularInt32({ $0.visitRepeatedUint32Field }, fieldNumber: 980),
+    .singularInt32({ $0.visitRepeatedUint64Field }, fieldNumber: 981),
+    .singularInt32({ $0.visitSingular }, fieldNumber: 982),
+    .singularInt32({ $0.visitSingularBoolField }, fieldNumber: 983),
+    .singularInt32({ $0.visitSingularBytesField }, fieldNumber: 984),
+    .singularInt32({ $0.visitSingularDoubleField }, fieldNumber: 985),
+    .singularInt32({ $0.visitSingularEnumField }, fieldNumber: 986),
+    .singularInt32({ $0.visitSingularFixed32Field }, fieldNumber: 987),
+    .singularInt32({ $0.visitSingularFixed64Field }, fieldNumber: 988),
+    .singularInt32({ $0.visitSingularFloatField }, fieldNumber: 989),
+    .singularInt32({ $0.visitSingularGroupField }, fieldNumber: 990),
+    .singularInt32({ $0.visitSingularInt32Field }, fieldNumber: 991),
+    .singularInt32({ $0.visitSingularInt64Field }, fieldNumber: 992),
+    .singularInt32({ $0.visitSingularMessageField }, fieldNumber: 993),
+    .singularInt32({ $0.visitSingularSfixed32Field }, fieldNumber: 994),
+    .singularInt32({ $0.visitSingularSfixed64Field }, fieldNumber: 995),
+    .singularInt32({ $0.visitSingularSint32Field }, fieldNumber: 996),
+    .singularInt32({ $0.visitSingularSint64Field }, fieldNumber: 997),
+    .singularInt32({ $0.visitSingularStringField }, fieldNumber: 998),
+    .singularInt32({ $0.visitSingularUint32Field }, fieldNumber: 999),
+    .singularInt32({ $0.visitSingularUint64Field }, fieldNumber: 1000),
+    .singularInt32({ $0.visitUnknown }, fieldNumber: 1001),
+    .singularInt32({ $0.wasDecoded }, fieldNumber: 1002),
+    .singularInt32({ $0.weak }, fieldNumber: 1003),
+    .singularInt32({ $0.weakDependency }, fieldNumber: 1004),
+    .singularInt32({ $0.`where` }, fieldNumber: 1005),
+    .singularInt32({ $0.wireFormat }, fieldNumber: 1006),
+    .singularInt32({ $0.with }, fieldNumber: 1007),
+    .singularInt32({ $0.withUnsafeBytes }, fieldNumber: 1008),
+    .singularInt32({ $0.withUnsafeMutableBytes }, fieldNumber: 1009),
+    .singularInt32({ $0.work }, fieldNumber: 1010),
+    .singularInt32({ $0.wrapped }, fieldNumber: 1011),
+    .singularInt32({ $0.wrappedType }, fieldNumber: 1012),
+    .singularInt32({ $0.wrappedValue }, fieldNumber: 1013),
+    .singularInt32({ $0.written }, fieldNumber: 1014),
+    .singularInt32({ $0.yday }, fieldNumber: 1015),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedFields) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -11848,6 +10512,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         if _storage._enumValueOptions != rhs_storage._enumValueOptions {return false}
         if _storage._equatable != rhs_storage._equatable {return false}
         if _storage._error != rhs_storage._error {return false}
+        if _storage._escaping != rhs_storage._escaping {return false}
         if _storage._expressibleByArrayLiteral != rhs_storage._expressibleByArrayLiteral {return false}
         if _storage._expressibleByDictionaryLiteral != rhs_storage._expressibleByDictionaryLiteral {return false}
         if _storage._ext != rhs_storage._ext {return false}
@@ -11859,6 +10524,8 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         if _storage._extension != rhs_storage._extension {return false}
         if _storage._extensionField != rhs_storage._extensionField {return false}
         if _storage._extensionFieldNumber != rhs_storage._extensionFieldNumber {return false}
+        if _storage._extensionFields != rhs_storage._extensionFields {return false}
+        if _storage._extensionFieldsAsMessageSet != rhs_storage._extensionFieldsAsMessageSet {return false}
         if _storage._extensionFieldValueSet != rhs_storage._extensionFieldValueSet {return false}
         if _storage._extensionMap != rhs_storage._extensionMap {return false}
         if _storage._extensionRange != rhs_storage._extensionRange {return false}
@@ -11916,6 +10583,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         if _storage._generatedCodeInfo != rhs_storage._generatedCodeInfo {return false}
         if _storage._get != rhs_storage._get {return false}
         if _storage._getExtensionValue != rhs_storage._getExtensionValue {return false}
+        if _storage._getValue != rhs_storage._getValue {return false}
         if _storage._googleapis != rhs_storage._googleapis {return false}
         if _storage._googleProtobufAny != rhs_storage._googleProtobufAny {return false}
         if _storage._googleProtobufApi != rhs_storage._googleProtobufApi {return false}
@@ -12093,6 +10761,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         if _storage._isExtension != rhs_storage._isExtension {return false}
         if _storage._isInitialized_p != rhs_storage._isInitialized_p {return false}
         if _storage._isNegative != rhs_storage._isNegative {return false}
+        if _storage._isUnset != rhs_storage._isUnset {return false}
         if _storage._itemTagsEncodedSize != rhs_storage._itemTagsEncodedSize {return false}
         if _storage._iterator != rhs_storage._iterator {return false}
         if _storage._javaGenerateEqualsAndHash != rhs_storage._javaGenerateEqualsAndHash {return false}
@@ -12147,6 +10816,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         if _storage._major != rhs_storage._major {return false}
         if _storage._makeAsyncIterator != rhs_storage._makeAsyncIterator {return false}
         if _storage._makeIterator != rhs_storage._makeIterator {return false}
+        if _storage._map != rhs_storage._map {return false}
         if _storage._mapEntry != rhs_storage._mapEntry {return false}
         if _storage._mapKeyType != rhs_storage._mapKeyType {return false}
         if _storage._mapToMessages != rhs_storage._mapToMessages {return false}
@@ -12203,6 +10873,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         if _storage._numberValue != rhs_storage._numberValue {return false}
         if _storage._objcClassPrefix != rhs_storage._objcClassPrefix {return false}
         if _storage._of != rhs_storage._of {return false}
+        if _storage._oneOf != rhs_storage._oneOf {return false}
         if _storage._oneofDecl != rhs_storage._oneofDecl {return false}
         if _storage._oneofDescriptorProto != rhs_storage._oneofDescriptorProto {return false}
         if _storage._oneofIndex != rhs_storage._oneofIndex {return false}
@@ -12226,8 +10897,22 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         if _storage._p != rhs_storage._p {return false}
         if _storage._package != rhs_storage._package {return false}
         if _storage._packed != rhs_storage._packed {return false}
+        if _storage._packedBool != rhs_storage._packedBool {return false}
+        if _storage._packedDouble != rhs_storage._packedDouble {return false}
+        if _storage._packedEnum != rhs_storage._packedEnum {return false}
         if _storage._packedEnumExtensionField != rhs_storage._packedEnumExtensionField {return false}
         if _storage._packedExtensionField != rhs_storage._packedExtensionField {return false}
+        if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false}
+        if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false}
+        if _storage._packedFloat != rhs_storage._packedFloat {return false}
+        if _storage._packedInt32 != rhs_storage._packedInt32 {return false}
+        if _storage._packedInt64 != rhs_storage._packedInt64 {return false}
+        if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false}
+        if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false}
+        if _storage._packedSint32 != rhs_storage._packedSint32 {return false}
+        if _storage._packedSint64 != rhs_storage._packedSint64 {return false}
+        if _storage._packedUint32 != rhs_storage._packedUint32 {return false}
+        if _storage._packedUint64 != rhs_storage._packedUint64 {return false}
         if _storage._padding != rhs_storage._padding {return false}
         if _storage._parent != rhs_storage._parent {return false}
         if _storage._parse != rhs_storage._parse {return false}
@@ -12304,11 +10989,29 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         if _storage._readBytes != rhs_storage._readBytes {return false}
         if _storage._register != rhs_storage._register {return false}
         if _storage._repeated != rhs_storage._repeated {return false}
+        if _storage._repeatedBool != rhs_storage._repeatedBool {return false}
+        if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false}
+        if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false}
+        if _storage._repeatedEnum != rhs_storage._repeatedEnum {return false}
         if _storage._repeatedEnumExtensionField != rhs_storage._repeatedEnumExtensionField {return false}
         if _storage._repeatedExtensionField != rhs_storage._repeatedExtensionField {return false}
         if _storage._repeatedFieldEncoding != rhs_storage._repeatedFieldEncoding {return false}
+        if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false}
+        if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false}
+        if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false}
+        if _storage._repeatedGroup != rhs_storage._repeatedGroup {return false}
         if _storage._repeatedGroupExtensionField != rhs_storage._repeatedGroupExtensionField {return false}
+        if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false}
+        if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false}
+        if _storage._repeatedMessage != rhs_storage._repeatedMessage {return false}
         if _storage._repeatedMessageExtensionField != rhs_storage._repeatedMessageExtensionField {return false}
+        if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false}
+        if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false}
+        if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false}
+        if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false}
+        if _storage._repeatedString != rhs_storage._repeatedString {return false}
+        if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false}
+        if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false}
         if _storage._repeating != rhs_storage._repeating {return false}
         if _storage._requestStreaming != rhs_storage._requestStreaming {return false}
         if _storage._requestTypeURL != rhs_storage._requestTypeURL {return false}
@@ -12346,6 +11049,24 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         if _storage._setExtensionValue != rhs_storage._setExtensionValue {return false}
         if _storage._shift != rhs_storage._shift {return false}
         if _storage._simpleExtensionMap != rhs_storage._simpleExtensionMap {return false}
+        if _storage._singularBool != rhs_storage._singularBool {return false}
+        if _storage._singularBytes != rhs_storage._singularBytes {return false}
+        if _storage._singularDouble != rhs_storage._singularDouble {return false}
+        if _storage._singularEnum != rhs_storage._singularEnum {return false}
+        if _storage._singularFixed32 != rhs_storage._singularFixed32 {return false}
+        if _storage._singularFixed64 != rhs_storage._singularFixed64 {return false}
+        if _storage._singularFloat != rhs_storage._singularFloat {return false}
+        if _storage._singularGroup != rhs_storage._singularGroup {return false}
+        if _storage._singularInt32 != rhs_storage._singularInt32 {return false}
+        if _storage._singularInt64 != rhs_storage._singularInt64 {return false}
+        if _storage._singularMessage != rhs_storage._singularMessage {return false}
+        if _storage._singularSfixed32 != rhs_storage._singularSfixed32 {return false}
+        if _storage._singularSfixed64 != rhs_storage._singularSfixed64 {return false}
+        if _storage._singularSint32 != rhs_storage._singularSint32 {return false}
+        if _storage._singularSint64 != rhs_storage._singularSint64 {return false}
+        if _storage._singularString != rhs_storage._singularString {return false}
+        if _storage._singularUint32 != rhs_storage._singularUint32 {return false}
+        if _storage._singularUint64 != rhs_storage._singularUint64 {return false}
         if _storage._size != rhs_storage._size {return false}
         if _storage._sizer != rhs_storage._sizer {return false}
         if _storage._source != rhs_storage._source {return false}
@@ -12400,6 +11121,7 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobu
         if _storage._timeIntervalSince1970 != rhs_storage._timeIntervalSince1970 {return false}
         if _storage._timeIntervalSinceReferenceDate != rhs_storage._timeIntervalSinceReferenceDate {return false}
         if _storage._timestamp != rhs_storage._timestamp {return false}
+        if _storage._toConcrete != rhs_storage._toConcrete {return false}
         if _storage._total != rhs_storage._total {return false}
         if _storage._totalArrayDepth != rhs_storage._totalArrayDepth {return false}
         if _storage._totalSize != rhs_storage._totalSize {return false}
diff --git a/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift b/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift
index 30ac619cd..8db7dc1e0 100644
--- a/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift
+++ b/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift
@@ -3355,6 +3355,18 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct escaping: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var escaping: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct ExpressibleByArrayLiteral: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -3487,6 +3499,30 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct extensionFields: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var extensionFields: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct extensionFieldsAsMessageSet: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var extensionFieldsAsMessageSet: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct ExtensionFieldValueSet: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -4171,6 +4207,18 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct getValue: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var getValue: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct googleapis: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -6295,6 +6343,18 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct isUnset: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var isUnset: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct itemTagsEncodedSize: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -6943,6 +7003,18 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct map: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var map: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct mapEntry: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -7615,6 +7687,18 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct oneOf: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var oneOf: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct oneofDecl: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -7891,6 +7975,42 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct packedBool: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedBool: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedDouble: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedDouble: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedEnum: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedEnum: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct PackedEnumExtensionField: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -7915,6 +8035,138 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct packedFixed32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedFixed32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedFixed64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedFixed64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedFloat: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedFloat: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedInt32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedInt32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedInt64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedInt64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedSFixed32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedSfixed32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedSFixed64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedSfixed64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedSInt32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedSint32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedSInt64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedSint64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedUInt32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedUint32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct packedUInt64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var packedUint64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct padding: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -8827,6 +9079,54 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct repeatedBool: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedBool: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedBytes: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedBytes: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedDouble: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedDouble: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedEnum: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedEnum: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct RepeatedEnumExtensionField: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -8863,6 +9163,54 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct repeatedFixed32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedFixed32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedFixed64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedFixed64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedFloat: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedFloat: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedGroup: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedGroup: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct RepeatedGroupExtensionField: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -8875,6 +9223,42 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct repeatedInt32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedInt32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedInt64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedInt64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedMessage: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedMessage: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct RepeatedMessageExtensionField: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -8887,6 +9271,90 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct repeatedSFixed32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedSfixed32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedSFixed64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedSfixed64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedSInt32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedSint32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedSInt64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedSint64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedString: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedString: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedUInt32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedUint32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct repeatedUInt64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var repeatedUint64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct repeating: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -9331,6 +9799,222 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct singularBool: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularBool: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularBytes: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularBytes: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularDouble: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularDouble: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularEnum: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularEnum: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularFixed32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularFixed32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularFixed64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularFixed64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularFloat: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularFloat: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularGroup: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularGroup: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularInt32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularInt32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularInt64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularInt64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularMessage: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularMessage: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularSFixed32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularSfixed32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularSFixed64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularSfixed64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularSInt32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularSint32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularSInt64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularSint64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularString: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularString: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularUInt32: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularUint32: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
+  struct singularUInt64: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var singularUint64: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct size: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -9979,6 +10663,18 @@ struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable {
     init() {}
   }
 
+  struct toConcrete: Sendable {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+
+    var toConcrete: Int32 = 0
+
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+  }
+
   struct total: Sendable {
     // SwiftProtobuf.Message conformance is added in an extension below. See the
     // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -11531,9 +12227,9 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: SwiftProto
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -11559,12 +12255,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.adjusted: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.adjusted != 0 {
-      try visitor.visitSingularInt32Field(value: self.adjusted, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.adjusted }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.adjusted, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.adjusted) -> Bool {
     if lhs.adjusted != rhs.adjusted {return false}
@@ -11591,12 +12285,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.aggregateVa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.aggregateValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.aggregateValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.aggregateValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.aggregateValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.aggregateValue) -> Bool {
     if lhs.aggregateValue != rhs.aggregateValue {return false}
@@ -11623,12 +12315,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allCases: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.allCases != 0 {
-      try visitor.visitSingularInt32Field(value: self.allCases, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.allCases }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allCases, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allCases) -> Bool {
     if lhs.allCases != rhs.allCases {return false}
@@ -11655,12 +12345,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allowAlias:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.allowAlias != 0 {
-      try visitor.visitSingularInt32Field(value: self.allowAlias, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.allowAlias }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allowAlias, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allowAlias) -> Bool {
     if lhs.allowAlias != rhs.allowAlias {return false}
@@ -11687,12 +12375,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrint
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.alwaysPrintEnumsAsInts != 0 {
-      try visitor.visitSingularInt32Field(value: self.alwaysPrintEnumsAsInts, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.alwaysPrintEnumsAsInts }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts) -> Bool {
     if lhs.alwaysPrintEnumsAsInts != rhs.alwaysPrintEnumsAsInts {return false}
@@ -11719,12 +12405,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrint
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.alwaysPrintInt64SAsNumbers != 0 {
-      try visitor.visitSingularInt32Field(value: self.alwaysPrintInt64SAsNumbers, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.alwaysPrintInt64SAsNumbers }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintInt64sAsNumbers, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintInt64sAsNumbers) -> Bool {
     if lhs.alwaysPrintInt64SAsNumbers != rhs.alwaysPrintInt64SAsNumbers {return false}
@@ -11751,12 +12435,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.annotation:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.annotation != 0 {
-      try visitor.visitSingularInt32Field(value: self.annotation, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.annotation }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.annotation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.annotation) -> Bool {
     if lhs.annotation != rhs.annotation {return false}
@@ -11783,12 +12465,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.any: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.any != 0 {
-      try visitor.visitSingularInt32Field(value: self.any, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.any }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.any, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.any) -> Bool {
     if lhs.any != rhs.any {return false}
@@ -11815,12 +12495,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyExtensio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.anyExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.anyExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.anyExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyExtensionField) -> Bool {
     if lhs.anyExtensionField != rhs.anyExtensionField {return false}
@@ -11847,12 +12525,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageE
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.anyMessageExtension != 0 {
-      try visitor.visitSingularInt32Field(value: self.anyMessageExtension, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.anyMessageExtension }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageExtension) -> Bool {
     if lhs.anyMessageExtension != rhs.anyMessageExtension {return false}
@@ -11879,12 +12555,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageS
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.anyMessageStorage != 0 {
-      try visitor.visitSingularInt32Field(value: self.anyMessageStorage, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.anyMessageStorage }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageStorage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageStorage) -> Bool {
     if lhs.anyMessageStorage != rhs.anyMessageStorage {return false}
@@ -11911,12 +12585,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyUnpackEr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.anyUnpackError != 0 {
-      try visitor.visitSingularInt32Field(value: self.anyUnpackError, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.anyUnpackError }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyUnpackError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyUnpackError) -> Bool {
     if lhs.anyUnpackError != rhs.anyUnpackError {return false}
@@ -11943,12 +12615,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Api: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.api != 0 {
-      try visitor.visitSingularInt32Field(value: self.api, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.api }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Api, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Api) -> Bool {
     if lhs.api != rhs.api {return false}
@@ -11975,12 +12645,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appended: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.appended != 0 {
-      try visitor.visitSingularInt32Field(value: self.appended, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.appended }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appended, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appended) -> Bool {
     if lhs.appended != rhs.appended {return false}
@@ -12007,12 +12675,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUIntH
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.appendUintHex != 0 {
-      try visitor.visitSingularInt32Field(value: self.appendUintHex, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.appendUintHex }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUIntHex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUIntHex) -> Bool {
     if lhs.appendUintHex != rhs.appendUintHex {return false}
@@ -12039,12 +12705,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUnkno
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.appendUnknown != 0 {
-      try visitor.visitSingularInt32Field(value: self.appendUnknown, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.appendUnknown }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUnknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUnknown) -> Bool {
     if lhs.appendUnknown != rhs.appendUnknown {return false}
@@ -12071,12 +12735,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.areAllIniti
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.areAllInitialized != 0 {
-      try visitor.visitSingularInt32Field(value: self.areAllInitialized, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.areAllInitialized }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.areAllInitialized, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.areAllInitialized) -> Bool {
     if lhs.areAllInitialized != rhs.areAllInitialized {return false}
@@ -12103,12 +12765,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Array: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.array != 0 {
-      try visitor.visitSingularInt32Field(value: self.array, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.array }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Array, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Array) -> Bool {
     if lhs.array != rhs.array {return false}
@@ -12135,12 +12795,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayDepth:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.arrayDepth != 0 {
-      try visitor.visitSingularInt32Field(value: self.arrayDepth, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.arrayDepth }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayDepth, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayDepth) -> Bool {
     if lhs.arrayDepth != rhs.arrayDepth {return false}
@@ -12167,12 +12825,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayLitera
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.arrayLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.arrayLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.arrayLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayLiteral) -> Bool {
     if lhs.arrayLiteral != rhs.arrayLiteral {return false}
@@ -12199,12 +12855,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arraySepara
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.arraySeparator != 0 {
-      try visitor.visitSingularInt32Field(value: self.arraySeparator, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.arraySeparator }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arraySeparator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arraySeparator) -> Bool {
     if lhs.arraySeparator != rhs.arraySeparator {return false}
@@ -12231,12 +12885,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asMessage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`as` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`as`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`as` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asMessage) -> Bool {
     if lhs.`as` != rhs.`as` {return false}
@@ -12263,12 +12915,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiOpenCu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.asciiOpenCurlyBracket != 0 {
-      try visitor.visitSingularInt32Field(value: self.asciiOpenCurlyBracket, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.asciiOpenCurlyBracket }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket) -> Bool {
     if lhs.asciiOpenCurlyBracket != rhs.asciiOpenCurlyBracket {return false}
@@ -12295,12 +12945,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiZero:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.asciiZero != 0 {
-      try visitor.visitSingularInt32Field(value: self.asciiZero, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.asciiZero }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiZero, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiZero) -> Bool {
     if lhs.asciiZero != rhs.asciiZero {return false}
@@ -12327,12 +12975,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.async: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.async != 0 {
-      try visitor.visitSingularInt32Field(value: self.async, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.async }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.async, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.async) -> Bool {
     if lhs.async != rhs.async {return false}
@@ -12359,12 +13005,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIterat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.asyncIterator != 0 {
-      try visitor.visitSingularInt32Field(value: self.asyncIterator, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.asyncIterator }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIterator) -> Bool {
     if lhs.asyncIterator != rhs.asyncIterator {return false}
@@ -12391,12 +13035,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIterat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.asyncIteratorProtocol != 0 {
-      try visitor.visitSingularInt32Field(value: self.asyncIteratorProtocol, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.asyncIteratorProtocol }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIteratorProtocol, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIteratorProtocol) -> Bool {
     if lhs.asyncIteratorProtocol != rhs.asyncIteratorProtocol {return false}
@@ -12423,12 +13065,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.asyncMessageSequence != 0 {
-      try visitor.visitSingularInt32Field(value: self.asyncMessageSequence, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.asyncMessageSequence }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncMessageSequence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncMessageSequence) -> Bool {
     if lhs.asyncMessageSequence != rhs.asyncMessageSequence {return false}
@@ -12455,12 +13095,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.available:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.available != 0 {
-      try visitor.visitSingularInt32Field(value: self.available, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.available }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.available, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.available) -> Bool {
     if lhs.available != rhs.available {return false}
@@ -12487,12 +13125,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.b: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.b != 0 {
-      try visitor.visitSingularInt32Field(value: self.b, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.b }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.b, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.b) -> Bool {
     if lhs.b != rhs.b {return false}
@@ -12519,12 +13155,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Base: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.base != 0 {
-      try visitor.visitSingularInt32Field(value: self.base, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.base }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Base, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Base) -> Bool {
     if lhs.base != rhs.base {return false}
@@ -12551,12 +13185,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.base64Value
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.base64Values != 0 {
-      try visitor.visitSingularInt32Field(value: self.base64Values, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.base64Values }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.base64Values, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.base64Values) -> Bool {
     if lhs.base64Values != rhs.base64Values {return false}
@@ -12583,12 +13215,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.baseAddress
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.baseAddress != 0 {
-      try visitor.visitSingularInt32Field(value: self.baseAddress, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.baseAddress }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.baseAddress, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.baseAddress) -> Bool {
     if lhs.baseAddress != rhs.baseAddress {return false}
@@ -12615,12 +13245,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BaseType: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.baseType != 0 {
-      try visitor.visitSingularInt32Field(value: self.baseType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.baseType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BaseType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BaseType) -> Bool {
     if lhs.baseType != rhs.baseType {return false}
@@ -12647,12 +13275,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.begin: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.begin != 0 {
-      try visitor.visitSingularInt32Field(value: self.begin, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.begin }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.begin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.begin) -> Bool {
     if lhs.begin != rhs.begin {return false}
@@ -12679,12 +13305,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binary: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binary != 0 {
-      try visitor.visitSingularInt32Field(value: self.binary, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binary }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binary, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binary) -> Bool {
     if lhs.binary != rhs.binary {return false}
@@ -12711,12 +13335,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryDecoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryDecoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryDecoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoder) -> Bool {
     if lhs.binaryDecoder != rhs.binaryDecoder {return false}
@@ -12743,12 +13365,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryDecodingError != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryDecodingError, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryDecodingError }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingError) -> Bool {
     if lhs.binaryDecodingError != rhs.binaryDecodingError {return false}
@@ -12775,12 +13395,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryDecodingOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryDecodingOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryDecodingOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingOptions) -> Bool {
     if lhs.binaryDecodingOptions != rhs.binaryDecodingOptions {return false}
@@ -12807,12 +13425,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDelim
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryDelimited != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryDelimited, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryDelimited }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDelimited, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDelimited) -> Bool {
     if lhs.binaryDelimited != rhs.binaryDelimited {return false}
@@ -12839,12 +13455,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryEncoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryEncoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryEncoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncoder) -> Bool {
     if lhs.binaryEncoder != rhs.binaryEncoder {return false}
@@ -12871,12 +13485,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryEncodingError != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryEncodingError, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryEncodingError }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingError) -> Bool {
     if lhs.binaryEncodingError != rhs.binaryEncodingError {return false}
@@ -12903,12 +13515,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryEncodingMessageSetSizeVisitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryEncodingMessageSetSizeVisitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryEncodingMessageSetSizeVisitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor) -> Bool {
     if lhs.binaryEncodingMessageSetSizeVisitor != rhs.binaryEncodingMessageSetSizeVisitor {return false}
@@ -12935,12 +13545,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryEncodingMessageSetVisitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryEncodingMessageSetVisitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryEncodingMessageSetVisitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor) -> Bool {
     if lhs.binaryEncodingMessageSetVisitor != rhs.binaryEncodingMessageSetVisitor {return false}
@@ -12967,12 +13575,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryEncodingOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryEncodingOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryEncodingOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingOptions) -> Bool {
     if lhs.binaryEncodingOptions != rhs.binaryEncodingOptions {return false}
@@ -12999,12 +13605,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryEncodingSizeVisitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryEncodingSizeVisitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryEncodingSizeVisitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor) -> Bool {
     if lhs.binaryEncodingSizeVisitor != rhs.binaryEncodingSizeVisitor {return false}
@@ -13031,12 +13635,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryEncodingVisitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryEncodingVisitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryEncodingVisitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor) -> Bool {
     if lhs.binaryEncodingVisitor != rhs.binaryEncodingVisitor {return false}
@@ -13063,12 +13665,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryOptio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryOptions) -> Bool {
     if lhs.binaryOptions != rhs.binaryOptions {return false}
@@ -13095,12 +13695,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.binaryProtobufDelimitedMessages != 0 {
-      try visitor.visitSingularInt32Field(value: self.binaryProtobufDelimitedMessages, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.binaryProtobufDelimitedMessages }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryProtobufDelimitedMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryProtobufDelimitedMessages) -> Bool {
     if lhs.binaryProtobufDelimitedMessages != rhs.binaryProtobufDelimitedMessages {return false}
@@ -13127,12 +13725,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bitPattern:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.bitPattern != 0 {
-      try visitor.visitSingularInt32Field(value: self.bitPattern, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bitPattern }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bitPattern, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bitPattern) -> Bool {
     if lhs.bitPattern != rhs.bitPattern {return false}
@@ -13159,12 +13755,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.body: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.body != 0 {
-      try visitor.visitSingularInt32Field(value: self.body, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.body }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.body, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.body) -> Bool {
     if lhs.body != rhs.body {return false}
@@ -13191,12 +13785,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BoolMessage
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.bool != 0 {
-      try visitor.visitSingularInt32Field(value: self.bool, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bool }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BoolMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BoolMessage) -> Bool {
     if lhs.bool != rhs.bool {return false}
@@ -13223,12 +13815,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.booleanLite
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.booleanLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.booleanLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.booleanLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.booleanLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.booleanLiteral) -> Bool {
     if lhs.booleanLiteral != rhs.booleanLiteral {return false}
@@ -13255,12 +13845,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BooleanLite
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.booleanLiteralType != 0 {
-      try visitor.visitSingularInt32Field(value: self.booleanLiteralType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.booleanLiteralType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BooleanLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BooleanLiteralType) -> Bool {
     if lhs.booleanLiteralType != rhs.booleanLiteralType {return false}
@@ -13287,12 +13875,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.boolValue:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.boolValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.boolValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.boolValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.boolValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.boolValue) -> Bool {
     if lhs.boolValue != rhs.boolValue {return false}
@@ -13319,12 +13905,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.buffer: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.buffer != 0 {
-      try visitor.visitSingularInt32Field(value: self.buffer, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.buffer }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.buffer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.buffer) -> Bool {
     if lhs.buffer != rhs.buffer {return false}
@@ -13351,12 +13935,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytes: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.bytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.bytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bytes }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytes) -> Bool {
     if lhs.bytes != rhs.bytes {return false}
@@ -13383,12 +13965,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesInGrou
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.bytesInGroup != 0 {
-      try visitor.visitSingularInt32Field(value: self.bytesInGroup, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bytesInGroup }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesInGroup, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesInGroup) -> Bool {
     if lhs.bytesInGroup != rhs.bytesInGroup {return false}
@@ -13415,12 +13995,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesNeeded
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.bytesNeeded != 0 {
-      try visitor.visitSingularInt32Field(value: self.bytesNeeded, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bytesNeeded }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesNeeded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesNeeded) -> Bool {
     if lhs.bytesNeeded != rhs.bytesNeeded {return false}
@@ -13447,12 +14025,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesRead:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.bytesRead != 0 {
-      try visitor.visitSingularInt32Field(value: self.bytesRead, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bytesRead }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesRead, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesRead) -> Bool {
     if lhs.bytesRead != rhs.bytesRead {return false}
@@ -13479,12 +14055,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BytesValue:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.bytesValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.bytesValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bytesValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BytesValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BytesValue) -> Bool {
     if lhs.bytesValue != rhs.bytesValue {return false}
@@ -13511,12 +14085,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.c: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.c != 0 {
-      try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.c }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.c, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.c) -> Bool {
     if lhs.c != rhs.c {return false}
@@ -13543,12 +14115,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.capitalizeN
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.capitalizeNext != 0 {
-      try visitor.visitSingularInt32Field(value: self.capitalizeNext, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.capitalizeNext }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.capitalizeNext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.capitalizeNext) -> Bool {
     if lhs.capitalizeNext != rhs.capitalizeNext {return false}
@@ -13575,12 +14145,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.cardinality
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.cardinality != 0 {
-      try visitor.visitSingularInt32Field(value: self.cardinality, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.cardinality }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.cardinality, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.cardinality) -> Bool {
     if lhs.cardinality != rhs.cardinality {return false}
@@ -13607,12 +14175,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CaseIterabl
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.caseIterable != 0 {
-      try visitor.visitSingularInt32Field(value: self.caseIterable, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.caseIterable }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CaseIterable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CaseIterable) -> Bool {
     if lhs.caseIterable != rhs.caseIterable {return false}
@@ -13639,12 +14205,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccEnableAre
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.ccEnableArenas != 0 {
-      try visitor.visitSingularInt32Field(value: self.ccEnableArenas, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.ccEnableArenas }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccEnableArenas, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccEnableArenas) -> Bool {
     if lhs.ccEnableArenas != rhs.ccEnableArenas {return false}
@@ -13671,12 +14235,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccGenericSe
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.ccGenericServices != 0 {
-      try visitor.visitSingularInt32Field(value: self.ccGenericServices, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.ccGenericServices }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccGenericServices) -> Bool {
     if lhs.ccGenericServices != rhs.ccGenericServices {return false}
@@ -13703,12 +14265,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Character:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.character != 0 {
-      try visitor.visitSingularInt32Field(value: self.character, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.character }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Character, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Character) -> Bool {
     if lhs.character != rhs.character {return false}
@@ -13735,12 +14295,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chars: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.chars != 0 {
-      try visitor.visitSingularInt32Field(value: self.chars, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.chars }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chars, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chars) -> Bool {
     if lhs.chars != rhs.chars {return false}
@@ -13767,12 +14325,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chunk: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.chunk != 0 {
-      try visitor.visitSingularInt32Field(value: self.chunk, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.chunk }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chunk, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chunk) -> Bool {
     if lhs.chunk != rhs.chunk {return false}
@@ -13799,12 +14355,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.classMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`class` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`class`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`class` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.classMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.classMessage) -> Bool {
     if lhs.`class` != rhs.`class` {return false}
@@ -13831,12 +14385,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAggreg
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearAggregateValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearAggregateValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearAggregateValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAggregateValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAggregateValue) -> Bool {
     if lhs.clearAggregateValue_p != rhs.clearAggregateValue_p {return false}
@@ -13863,12 +14415,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAllowA
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearAllowAlias_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearAllowAlias_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearAllowAlias_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAllowAlias, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAllowAlias) -> Bool {
     if lhs.clearAllowAlias_p != rhs.clearAllowAlias_p {return false}
@@ -13895,12 +14445,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearBegin:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearBegin_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearBegin_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearBegin_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearBegin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearBegin) -> Bool {
     if lhs.clearBegin_p != rhs.clearBegin_p {return false}
@@ -13927,12 +14475,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcEnab
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearCcEnableArenas_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearCcEnableArenas_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearCcEnableArenas_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcEnableArenas, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcEnableArenas) -> Bool {
     if lhs.clearCcEnableArenas_p != rhs.clearCcEnableArenas_p {return false}
@@ -13959,12 +14505,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcGene
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearCcGenericServices_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearCcGenericServices_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearCcGenericServices_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcGenericServices) -> Bool {
     if lhs.clearCcGenericServices_p != rhs.clearCcGenericServices_p {return false}
@@ -13991,12 +14535,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearClient
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearClientStreaming_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearClientStreaming_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearClientStreaming_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearClientStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearClientStreaming) -> Bool {
     if lhs.clearClientStreaming_p != rhs.clearClientStreaming_p {return false}
@@ -14023,12 +14565,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCsharp
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearCsharpNamespace_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearCsharpNamespace_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearCsharpNamespace_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCsharpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCsharpNamespace) -> Bool {
     if lhs.clearCsharpNamespace_p != rhs.clearCsharpNamespace_p {return false}
@@ -14055,12 +14595,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCtype:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearCtype_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearCtype_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearCtype_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCtype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCtype) -> Bool {
     if lhs.clearCtype_p != rhs.clearCtype_p {return false}
@@ -14087,12 +14625,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDebugR
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearDebugRedact_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearDebugRedact_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearDebugRedact_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDebugRedact, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDebugRedact) -> Bool {
     if lhs.clearDebugRedact_p != rhs.clearDebugRedact_p {return false}
@@ -14119,12 +14655,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearDefaultValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearDefaultValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearDefaultValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultValue) -> Bool {
     if lhs.clearDefaultValue_p != rhs.clearDefaultValue_p {return false}
@@ -14151,12 +14685,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprec
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearDeprecated_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearDeprecated_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearDeprecated_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecated) -> Bool {
     if lhs.clearDeprecated_p != rhs.clearDeprecated_p {return false}
@@ -14183,12 +14715,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprec
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearDeprecatedLegacyJsonFieldConflicts_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearDeprecatedLegacyJsonFieldConflicts_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecatedLegacyJsonFieldConflicts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecatedLegacyJsonFieldConflicts) -> Bool {
     if lhs.clearDeprecatedLegacyJsonFieldConflicts_p != rhs.clearDeprecatedLegacyJsonFieldConflicts_p {return false}
@@ -14215,12 +14745,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDouble
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearDoubleValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearDoubleValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearDoubleValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDoubleValue) -> Bool {
     if lhs.clearDoubleValue_p != rhs.clearDoubleValue_p {return false}
@@ -14247,12 +14775,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearEdition_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearEdition_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearEdition_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEdition) -> Bool {
     if lhs.clearEdition_p != rhs.clearEdition_p {return false}
@@ -14279,12 +14805,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnd: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearEnd_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearEnd_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearEnd_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnd, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnd) -> Bool {
     if lhs.clearEnd_p != rhs.clearEnd_p {return false}
@@ -14311,12 +14835,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnumTy
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearEnumType_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearEnumType_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearEnumType_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnumType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnumType) -> Bool {
     if lhs.clearEnumType_p != rhs.clearEnumType_p {return false}
@@ -14343,12 +14865,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtend
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearExtendee_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearExtendee_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearExtendee_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtendee, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtendee) -> Bool {
     if lhs.clearExtendee_p != rhs.clearExtendee_p {return false}
@@ -14375,12 +14895,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtens
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearExtensionValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearExtensionValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearExtensionValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtensionValue) -> Bool {
     if lhs.clearExtensionValue_p != rhs.clearExtensionValue_p {return false}
@@ -14407,12 +14925,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatur
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearFeatures_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearFeatures_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearFeatures_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatures) -> Bool {
     if lhs.clearFeatures_p != rhs.clearFeatures_p {return false}
@@ -14439,12 +14955,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFieldP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearFieldPresence_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearFieldPresence_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearFieldPresence_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFieldPresence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFieldPresence) -> Bool {
     if lhs.clearFieldPresence_p != rhs.clearFieldPresence_p {return false}
@@ -14471,12 +14985,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFullNa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearFullName_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearFullName_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearFullName_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFullName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFullName) -> Bool {
     if lhs.clearFullName_p != rhs.clearFullName_p {return false}
@@ -14503,12 +15015,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearGoPack
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearGoPackage_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearGoPackage_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearGoPackage_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearGoPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearGoPackage) -> Bool {
     if lhs.clearGoPackage_p != rhs.clearGoPackage_p {return false}
@@ -14535,12 +15045,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdempo
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearIdempotencyLevel_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearIdempotencyLevel_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearIdempotencyLevel_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdempotencyLevel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdempotencyLevel) -> Bool {
     if lhs.clearIdempotencyLevel_p != rhs.clearIdempotencyLevel_p {return false}
@@ -14567,12 +15075,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdenti
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearIdentifierValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearIdentifierValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearIdentifierValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdentifierValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdentifierValue) -> Bool {
     if lhs.clearIdentifierValue_p != rhs.clearIdentifierValue_p {return false}
@@ -14599,12 +15105,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearInputT
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearInputType_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearInputType_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearInputType_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearInputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearInputType) -> Bool {
     if lhs.clearInputType_p != rhs.clearInputType_p {return false}
@@ -14631,12 +15135,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIsExte
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearIsExtension_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearIsExtension_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearIsExtension_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIsExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIsExtension) -> Bool {
     if lhs.clearIsExtension_p != rhs.clearIsExtension_p {return false}
@@ -14663,12 +15165,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGe
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearJavaGenerateEqualsAndHash_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearJavaGenerateEqualsAndHash_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearJavaGenerateEqualsAndHash_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash) -> Bool {
     if lhs.clearJavaGenerateEqualsAndHash_p != rhs.clearJavaGenerateEqualsAndHash_p {return false}
@@ -14695,12 +15195,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGe
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearJavaGenericServices_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearJavaGenericServices_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearJavaGenericServices_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenericServices) -> Bool {
     if lhs.clearJavaGenericServices_p != rhs.clearJavaGenericServices_p {return false}
@@ -14727,12 +15225,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaMu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearJavaMultipleFiles_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearJavaMultipleFiles_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearJavaMultipleFiles_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles) -> Bool {
     if lhs.clearJavaMultipleFiles_p != rhs.clearJavaMultipleFiles_p {return false}
@@ -14759,12 +15255,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaOu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearJavaOuterClassname_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearJavaOuterClassname_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearJavaOuterClassname_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaOuterClassname, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaOuterClassname) -> Bool {
     if lhs.clearJavaOuterClassname_p != rhs.clearJavaOuterClassname_p {return false}
@@ -14791,12 +15285,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaPa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearJavaPackage_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearJavaPackage_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearJavaPackage_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaPackage) -> Bool {
     if lhs.clearJavaPackage_p != rhs.clearJavaPackage_p {return false}
@@ -14823,12 +15315,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaSt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearJavaStringCheckUtf8_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearJavaStringCheckUtf8_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearJavaStringCheckUtf8_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8) -> Bool {
     if lhs.clearJavaStringCheckUtf8_p != rhs.clearJavaStringCheckUtf8_p {return false}
@@ -14855,12 +15345,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonFo
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearJsonFormat_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearJsonFormat_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearJsonFormat_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonFormat) -> Bool {
     if lhs.clearJsonFormat_p != rhs.clearJsonFormat_p {return false}
@@ -14887,12 +15375,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonNa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearJsonName_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearJsonName_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearJsonName_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonName) -> Bool {
     if lhs.clearJsonName_p != rhs.clearJsonName_p {return false}
@@ -14919,12 +15405,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJstype
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearJstype_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearJstype_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearJstype_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJstype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJstype) -> Bool {
     if lhs.clearJstype_p != rhs.clearJstype_p {return false}
@@ -14951,12 +15435,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLabel:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearLabel_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearLabel_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearLabel_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLabel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLabel) -> Bool {
     if lhs.clearLabel_p != rhs.clearLabel_p {return false}
@@ -14983,12 +15465,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLazy:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearLazy_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearLazy_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearLazy_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLazy) -> Bool {
     if lhs.clearLazy_p != rhs.clearLazy_p {return false}
@@ -15015,12 +15495,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLeadin
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearLeadingComments_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearLeadingComments_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearLeadingComments_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLeadingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLeadingComments) -> Bool {
     if lhs.clearLeadingComments_p != rhs.clearLeadingComments_p {return false}
@@ -15047,12 +15525,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMapEnt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearMapEntry_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearMapEntry_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearMapEntry_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMapEntry, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMapEntry) -> Bool {
     if lhs.clearMapEntry_p != rhs.clearMapEntry_p {return false}
@@ -15079,12 +15555,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMaximu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearMaximumEdition_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearMaximumEdition_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearMaximumEdition_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMaximumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMaximumEdition) -> Bool {
     if lhs.clearMaximumEdition_p != rhs.clearMaximumEdition_p {return false}
@@ -15111,12 +15585,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearMessageEncoding_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearMessageEncoding_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearMessageEncoding_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageEncoding) -> Bool {
     if lhs.clearMessageEncoding_p != rhs.clearMessageEncoding_p {return false}
@@ -15143,12 +15615,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearMessageSetWireFormat_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearMessageSetWireFormat_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearMessageSetWireFormat_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat) -> Bool {
     if lhs.clearMessageSetWireFormat_p != rhs.clearMessageSetWireFormat_p {return false}
@@ -15175,12 +15645,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMinimu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearMinimumEdition_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearMinimumEdition_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearMinimumEdition_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMinimumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMinimumEdition) -> Bool {
     if lhs.clearMinimumEdition_p != rhs.clearMinimumEdition_p {return false}
@@ -15207,12 +15675,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearName:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearName_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearName_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearName_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearName) -> Bool {
     if lhs.clearName_p != rhs.clearName_p {return false}
@@ -15239,12 +15705,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNamePa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearNamePart_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearNamePart_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearNamePart_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNamePart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNamePart) -> Bool {
     if lhs.clearNamePart_p != rhs.clearNamePart_p {return false}
@@ -15271,12 +15735,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNegati
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearNegativeIntValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearNegativeIntValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearNegativeIntValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNegativeIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNegativeIntValue) -> Bool {
     if lhs.clearNegativeIntValue_p != rhs.clearNegativeIntValue_p {return false}
@@ -15303,12 +15765,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNoStan
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearNoStandardDescriptorAccessor_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearNoStandardDescriptorAccessor_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearNoStandardDescriptorAccessor_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor) -> Bool {
     if lhs.clearNoStandardDescriptorAccessor_p != rhs.clearNoStandardDescriptorAccessor_p {return false}
@@ -15335,12 +15795,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNumber
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearNumber_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearNumber_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearNumber_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNumber) -> Bool {
     if lhs.clearNumber_p != rhs.clearNumber_p {return false}
@@ -15367,12 +15825,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearObjcCl
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearObjcClassPrefix_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearObjcClassPrefix_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearObjcClassPrefix_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearObjcClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearObjcClassPrefix) -> Bool {
     if lhs.clearObjcClassPrefix_p != rhs.clearObjcClassPrefix_p {return false}
@@ -15399,12 +15855,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOneofI
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearOneofIndex_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearOneofIndex_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearOneofIndex_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOneofIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOneofIndex) -> Bool {
     if lhs.clearOneofIndex_p != rhs.clearOneofIndex_p {return false}
@@ -15431,12 +15885,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptimi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearOptimizeFor_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearOptimizeFor_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearOptimizeFor_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptimizeFor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptimizeFor) -> Bool {
     if lhs.clearOptimizeFor_p != rhs.clearOptimizeFor_p {return false}
@@ -15463,12 +15915,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOption
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearOptions_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearOptions_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearOptions_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptions) -> Bool {
     if lhs.clearOptions_p != rhs.clearOptions_p {return false}
@@ -15495,12 +15945,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOutput
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearOutputType_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearOutputType_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearOutputType_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOutputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOutputType) -> Bool {
     if lhs.clearOutputType_p != rhs.clearOutputType_p {return false}
@@ -15527,12 +15975,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPackag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearPackage_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearPackage_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearPackage_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPackage) -> Bool {
     if lhs.clearPackage_p != rhs.clearPackage_p {return false}
@@ -15559,12 +16005,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearPacked_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearPacked_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearPacked_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPacked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPacked) -> Bool {
     if lhs.clearPacked_p != rhs.clearPacked_p {return false}
@@ -15591,12 +16035,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpCla
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearPhpClassPrefix_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearPhpClassPrefix_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearPhpClassPrefix_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpClassPrefix) -> Bool {
     if lhs.clearPhpClassPrefix_p != rhs.clearPhpClassPrefix_p {return false}
@@ -15623,12 +16065,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpGen
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearPhpGenericServices_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearPhpGenericServices_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearPhpGenericServices_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpGenericServices) -> Bool {
     if lhs.clearPhpGenericServices_p != rhs.clearPhpGenericServices_p {return false}
@@ -15655,12 +16095,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpMet
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearPhpMetadataNamespace_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearPhpMetadataNamespace_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearPhpMetadataNamespace_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace) -> Bool {
     if lhs.clearPhpMetadataNamespace_p != rhs.clearPhpMetadataNamespace_p {return false}
@@ -15687,12 +16125,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpNam
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearPhpNamespace_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearPhpNamespace_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearPhpNamespace_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpNamespace) -> Bool {
     if lhs.clearPhpNamespace_p != rhs.clearPhpNamespace_p {return false}
@@ -15719,12 +16155,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPositi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearPositiveIntValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearPositiveIntValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearPositiveIntValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPositiveIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPositiveIntValue) -> Bool {
     if lhs.clearPositiveIntValue_p != rhs.clearPositiveIntValue_p {return false}
@@ -15751,12 +16185,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearProto3
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearProto3Optional_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearProto3Optional_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearProto3Optional_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearProto3Optional, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearProto3Optional) -> Bool {
     if lhs.clearProto3Optional_p != rhs.clearProto3Optional_p {return false}
@@ -15783,12 +16215,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPyGene
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearPyGenericServices_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearPyGenericServices_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearPyGenericServices_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPyGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPyGenericServices) -> Bool {
     if lhs.clearPyGenericServices_p != rhs.clearPyGenericServices_p {return false}
@@ -15815,12 +16245,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearRepeated_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearRepeated_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearRepeated_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeated) -> Bool {
     if lhs.clearRepeated_p != rhs.clearRepeated_p {return false}
@@ -15847,12 +16275,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearRepeatedFieldEncoding_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearRepeatedFieldEncoding_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearRepeatedFieldEncoding_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeatedFieldEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeatedFieldEncoding) -> Bool {
     if lhs.clearRepeatedFieldEncoding_p != rhs.clearRepeatedFieldEncoding_p {return false}
@@ -15879,12 +16305,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearReserv
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearReserved_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearReserved_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearReserved_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearReserved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearReserved) -> Bool {
     if lhs.clearReserved_p != rhs.clearReserved_p {return false}
@@ -15911,12 +16335,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRetent
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearRetention_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearRetention_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearRetention_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRetention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRetention) -> Bool {
     if lhs.clearRetention_p != rhs.clearRetention_p {return false}
@@ -15943,12 +16365,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRubyPa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearRubyPackage_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearRubyPackage_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearRubyPackage_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRubyPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRubyPackage) -> Bool {
     if lhs.clearRubyPackage_p != rhs.clearRubyPackage_p {return false}
@@ -15975,12 +16395,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSemant
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearSemantic_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearSemantic_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearSemantic_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSemantic, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSemantic) -> Bool {
     if lhs.clearSemantic_p != rhs.clearSemantic_p {return false}
@@ -16007,12 +16425,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearServer
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearServerStreaming_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearServerStreaming_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearServerStreaming_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearServerStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearServerStreaming) -> Bool {
     if lhs.clearServerStreaming_p != rhs.clearServerStreaming_p {return false}
@@ -16039,12 +16455,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSource
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearSourceCodeInfo_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearSourceCodeInfo_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearSourceCodeInfo_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceCodeInfo) -> Bool {
     if lhs.clearSourceCodeInfo_p != rhs.clearSourceCodeInfo_p {return false}
@@ -16071,12 +16485,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSource
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearSourceContext_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearSourceContext_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearSourceContext_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceContext) -> Bool {
     if lhs.clearSourceContext_p != rhs.clearSourceContext_p {return false}
@@ -16103,12 +16515,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSource
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearSourceFile_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearSourceFile_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearSourceFile_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceFile, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceFile) -> Bool {
     if lhs.clearSourceFile_p != rhs.clearSourceFile_p {return false}
@@ -16135,12 +16545,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStart:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearStart_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearStart_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearStart_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStart) -> Bool {
     if lhs.clearStart_p != rhs.clearStart_p {return false}
@@ -16167,12 +16575,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearString
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearStringValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearStringValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearStringValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStringValue) -> Bool {
     if lhs.clearStringValue_p != rhs.clearStringValue_p {return false}
@@ -16199,12 +16605,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearSwiftPrefix_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearSwiftPrefix_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearSwiftPrefix_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSwiftPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSwiftPrefix) -> Bool {
     if lhs.clearSwiftPrefix_p != rhs.clearSwiftPrefix_p {return false}
@@ -16231,12 +16635,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSyntax
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearSyntax_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearSyntax_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearSyntax_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSyntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSyntax) -> Bool {
     if lhs.clearSyntax_p != rhs.clearSyntax_p {return false}
@@ -16263,12 +16665,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTraili
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearTrailingComments_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearTrailingComments_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearTrailingComments_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTrailingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTrailingComments) -> Bool {
     if lhs.clearTrailingComments_p != rhs.clearTrailingComments_p {return false}
@@ -16295,12 +16695,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearType:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearType_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearType_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearType_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearType) -> Bool {
     if lhs.clearType_p != rhs.clearType_p {return false}
@@ -16327,12 +16725,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTypeNa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearTypeName_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearTypeName_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearTypeName_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTypeName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTypeName) -> Bool {
     if lhs.clearTypeName_p != rhs.clearTypeName_p {return false}
@@ -16359,12 +16755,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUnveri
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearUnverifiedLazy_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearUnverifiedLazy_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearUnverifiedLazy_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUnverifiedLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUnverifiedLazy) -> Bool {
     if lhs.clearUnverifiedLazy_p != rhs.clearUnverifiedLazy_p {return false}
@@ -16391,12 +16785,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUtf8Va
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearUtf8Validation_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearUtf8Validation_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearUtf8Validation_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUtf8Validation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUtf8Validation) -> Bool {
     if lhs.clearUtf8Validation_p != rhs.clearUtf8Validation_p {return false}
@@ -16423,12 +16815,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearValue:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearValue) -> Bool {
     if lhs.clearValue_p != rhs.clearValue_p {return false}
@@ -16455,12 +16845,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVerifi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearVerification_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearVerification_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearVerification_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVerification, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVerification) -> Bool {
     if lhs.clearVerification_p != rhs.clearVerification_p {return false}
@@ -16487,12 +16875,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearWeak:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clearWeak_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.clearWeak_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clearWeak_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearWeak, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearWeak) -> Bool {
     if lhs.clearWeak_p != rhs.clearWeak_p {return false}
@@ -16519,12 +16905,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clientStrea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.clientStreaming != 0 {
-      try visitor.visitSingularInt32Field(value: self.clientStreaming, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clientStreaming }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clientStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clientStreaming) -> Bool {
     if lhs.clientStreaming != rhs.clientStreaming {return false}
@@ -16551,12 +16935,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codePoint:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.codePoint != 0 {
-      try visitor.visitSingularInt32Field(value: self.codePoint, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.codePoint }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codePoint, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codePoint) -> Bool {
     if lhs.codePoint != rhs.codePoint {return false}
@@ -16583,12 +16965,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codeUnits:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.codeUnits != 0 {
-      try visitor.visitSingularInt32Field(value: self.codeUnits, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.codeUnits }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codeUnits, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codeUnits) -> Bool {
     if lhs.codeUnits != rhs.codeUnits {return false}
@@ -16615,12 +16995,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Collection:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.collection != 0 {
-      try visitor.visitSingularInt32Field(value: self.collection, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.collection }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Collection, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Collection) -> Bool {
     if lhs.collection != rhs.collection {return false}
@@ -16647,12 +17025,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.com: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.com != 0 {
-      try visitor.visitSingularInt32Field(value: self.com, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.com }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.com, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.com) -> Bool {
     if lhs.com != rhs.com {return false}
@@ -16679,12 +17055,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.comma: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.comma != 0 {
-      try visitor.visitSingularInt32Field(value: self.comma, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.comma }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.comma, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.comma) -> Bool {
     if lhs.comma != rhs.comma {return false}
@@ -16711,12 +17085,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CommonMessa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.commonMessageConformances != 0 {
-      try visitor.visitSingularInt32Field(value: self.commonMessageConformances, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.commonMessageConformances }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CommonMessageConformances, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CommonMessageConformances) -> Bool {
     if lhs.commonMessageConformances != rhs.commonMessageConformances {return false}
@@ -16743,12 +17115,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.consumedByt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.consumedBytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.consumedBytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.consumedBytes }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.consumedBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.consumedBytes) -> Bool {
     if lhs.consumedBytes != rhs.consumedBytes {return false}
@@ -16775,12 +17145,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contentsOf:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.contentsOf != 0 {
-      try visitor.visitSingularInt32Field(value: self.contentsOf, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.contentsOf }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contentsOf, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contentsOf) -> Bool {
     if lhs.contentsOf != rhs.contentsOf {return false}
@@ -16807,12 +17175,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.count: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.count != 0 {
-      try visitor.visitSingularInt32Field(value: self.count, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.count }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.count, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.count) -> Bool {
     if lhs.count != rhs.count {return false}
@@ -16839,12 +17205,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.countVarint
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.countVarintsInBuffer != 0 {
-      try visitor.visitSingularInt32Field(value: self.countVarintsInBuffer, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.countVarintsInBuffer }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.countVarintsInBuffer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.countVarintsInBuffer) -> Bool {
     if lhs.countVarintsInBuffer != rhs.countVarintsInBuffer {return false}
@@ -16871,12 +17235,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.csharpNames
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.csharpNamespace != 0 {
-      try visitor.visitSingularInt32Field(value: self.csharpNamespace, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.csharpNamespace }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.csharpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.csharpNamespace) -> Bool {
     if lhs.csharpNamespace != rhs.csharpNamespace {return false}
@@ -16903,12 +17265,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ctype: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.ctype != 0 {
-      try visitor.visitSingularInt32Field(value: self.ctype, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.ctype }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ctype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ctype) -> Bool {
     if lhs.ctype != rhs.ctype {return false}
@@ -16935,12 +17295,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.customCodab
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.customCodable != 0 {
-      try visitor.visitSingularInt32Field(value: self.customCodable, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.customCodable }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.customCodable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.customCodable) -> Bool {
     if lhs.customCodable != rhs.customCodable {return false}
@@ -16967,12 +17325,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.d: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.d != 0 {
-      try visitor.visitSingularInt32Field(value: self.d, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.d }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.d, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.d) -> Bool {
     if lhs.d != rhs.d {return false}
@@ -16999,12 +17355,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DataMessage
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.data != 0 {
-      try visitor.visitSingularInt32Field(value: self.data, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.data }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DataMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DataMessage) -> Bool {
     if lhs.data != rhs.data {return false}
@@ -17031,12 +17385,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dataResult:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.dataResult != 0 {
-      try visitor.visitSingularInt32Field(value: self.dataResult, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.dataResult }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dataResult, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dataResult) -> Bool {
     if lhs.dataResult != rhs.dataResult {return false}
@@ -17063,12 +17415,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.date: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.date != 0 {
-      try visitor.visitSingularInt32Field(value: self.date, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.date }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.date, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.date) -> Bool {
     if lhs.date != rhs.date {return false}
@@ -17095,12 +17445,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daySec: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.daySec != 0 {
-      try visitor.visitSingularInt32Field(value: self.daySec, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.daySec }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daySec, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daySec) -> Bool {
     if lhs.daySec != rhs.daySec {return false}
@@ -17127,12 +17475,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daysSinceEp
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.daysSinceEpoch != 0 {
-      try visitor.visitSingularInt32Field(value: self.daysSinceEpoch, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.daysSinceEpoch }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daysSinceEpoch, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daysSinceEpoch) -> Bool {
     if lhs.daysSinceEpoch != rhs.daysSinceEpoch {return false}
@@ -17159,12 +17505,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugDescri
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.debugDescription_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.debugDescription_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.debugDescription_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugDescriptionMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugDescriptionMessage) -> Bool {
     if lhs.debugDescription_p != rhs.debugDescription_p {return false}
@@ -17191,12 +17535,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugRedact
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.debugRedact != 0 {
-      try visitor.visitSingularInt32Field(value: self.debugRedact, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.debugRedact }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugRedact, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugRedact) -> Bool {
     if lhs.debugRedact != rhs.debugRedact {return false}
@@ -17223,12 +17565,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.declaration
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.declaration != 0 {
-      try visitor.visitSingularInt32Field(value: self.declaration, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.declaration }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.declaration, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.declaration) -> Bool {
     if lhs.declaration != rhs.declaration {return false}
@@ -17255,12 +17595,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoded: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decoded != 0 {
-      try visitor.visitSingularInt32Field(value: self.decoded, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decoded }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoded) -> Bool {
     if lhs.decoded != rhs.decoded {return false}
@@ -17287,12 +17625,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodedFrom
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodedFromJsonnull != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodedFromJsonnull, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodedFromJsonnull }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodedFromJSONNull, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodedFromJSONNull) -> Bool {
     if lhs.decodedFromJsonnull != rhs.decodedFromJsonnull {return false}
@@ -17319,12 +17655,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExten
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionField) -> Bool {
     if lhs.decodeExtensionField != rhs.decodeExtensionField {return false}
@@ -17351,12 +17685,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExten
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeExtensionFieldsAsMessageSet != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeExtensionFieldsAsMessageSet, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeExtensionFieldsAsMessageSet }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet) -> Bool {
     if lhs.decodeExtensionFieldsAsMessageSet != rhs.decodeExtensionFieldsAsMessageSet {return false}
@@ -17383,12 +17715,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeJSON:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeJson != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeJson, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeJson }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeJSON, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeJSON) -> Bool {
     if lhs.decodeJson != rhs.decodeJson {return false}
@@ -17415,12 +17745,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMapFi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeMapField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeMapField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeMapField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMapField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMapField) -> Bool {
     if lhs.decodeMapField != rhs.decodeMapField {return false}
@@ -17447,12 +17775,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMessa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeMessage != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeMessage, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeMessage }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMessageMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMessageMessage) -> Bool {
     if lhs.decodeMessage != rhs.decodeMessage {return false}
@@ -17479,12 +17805,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoder: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.decoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoder) -> Bool {
     if lhs.decoder != rhs.decoder {return false}
@@ -17511,12 +17835,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeated != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeated, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeated }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeated) -> Bool {
     if lhs.decodeRepeated != rhs.decodeRepeated {return false}
@@ -17543,12 +17865,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedBoolField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedBoolField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedBoolField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField) -> Bool {
     if lhs.decodeRepeatedBoolField != rhs.decodeRepeatedBoolField {return false}
@@ -17575,12 +17895,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedBytesField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedBytesField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedBytesField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField) -> Bool {
     if lhs.decodeRepeatedBytesField != rhs.decodeRepeatedBytesField {return false}
@@ -17607,12 +17925,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedDoubleField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedDoubleField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedDoubleField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField) -> Bool {
     if lhs.decodeRepeatedDoubleField != rhs.decodeRepeatedDoubleField {return false}
@@ -17639,12 +17955,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedEnumField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedEnumField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedEnumField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField) -> Bool {
     if lhs.decodeRepeatedEnumField != rhs.decodeRepeatedEnumField {return false}
@@ -17671,12 +17985,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedFixed32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedFixed32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedFixed32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field) -> Bool {
     if lhs.decodeRepeatedFixed32Field != rhs.decodeRepeatedFixed32Field {return false}
@@ -17703,12 +18015,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedFixed64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedFixed64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedFixed64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field) -> Bool {
     if lhs.decodeRepeatedFixed64Field != rhs.decodeRepeatedFixed64Field {return false}
@@ -17735,12 +18045,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedFloatField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedFloatField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedFloatField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField) -> Bool {
     if lhs.decodeRepeatedFloatField != rhs.decodeRepeatedFloatField {return false}
@@ -17767,12 +18075,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedGroupField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedGroupField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedGroupField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField) -> Bool {
     if lhs.decodeRepeatedGroupField != rhs.decodeRepeatedGroupField {return false}
@@ -17799,12 +18105,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedInt32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedInt32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedInt32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field) -> Bool {
     if lhs.decodeRepeatedInt32Field != rhs.decodeRepeatedInt32Field {return false}
@@ -17831,12 +18135,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedInt64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedInt64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedInt64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field) -> Bool {
     if lhs.decodeRepeatedInt64Field != rhs.decodeRepeatedInt64Field {return false}
@@ -17863,12 +18165,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedMessageField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedMessageField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedMessageField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField) -> Bool {
     if lhs.decodeRepeatedMessageField != rhs.decodeRepeatedMessageField {return false}
@@ -17895,12 +18195,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedSfixed32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedSfixed32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedSfixed32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field) -> Bool {
     if lhs.decodeRepeatedSfixed32Field != rhs.decodeRepeatedSfixed32Field {return false}
@@ -17927,12 +18225,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedSfixed64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedSfixed64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedSfixed64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field) -> Bool {
     if lhs.decodeRepeatedSfixed64Field != rhs.decodeRepeatedSfixed64Field {return false}
@@ -17959,12 +18255,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedSint32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedSint32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedSint32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field) -> Bool {
     if lhs.decodeRepeatedSint32Field != rhs.decodeRepeatedSint32Field {return false}
@@ -17991,12 +18285,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedSint64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedSint64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedSint64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field) -> Bool {
     if lhs.decodeRepeatedSint64Field != rhs.decodeRepeatedSint64Field {return false}
@@ -18023,12 +18315,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedStringField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedStringField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedStringField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedStringField) -> Bool {
     if lhs.decodeRepeatedStringField != rhs.decodeRepeatedStringField {return false}
@@ -18055,12 +18345,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedUint32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedUint32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedUint32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field) -> Bool {
     if lhs.decodeRepeatedUint32Field != rhs.decodeRepeatedUint32Field {return false}
@@ -18087,12 +18375,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepea
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeRepeatedUint64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeRepeatedUint64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeRepeatedUint64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field) -> Bool {
     if lhs.decodeRepeatedUint64Field != rhs.decodeRepeatedUint64Field {return false}
@@ -18119,12 +18405,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingular != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingular, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingular }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingular, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingular) -> Bool {
     if lhs.decodeSingular != rhs.decodeSingular {return false}
@@ -18151,12 +18435,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularBoolField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularBoolField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularBoolField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBoolField) -> Bool {
     if lhs.decodeSingularBoolField != rhs.decodeSingularBoolField {return false}
@@ -18183,12 +18465,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularBytesField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularBytesField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularBytesField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBytesField) -> Bool {
     if lhs.decodeSingularBytesField != rhs.decodeSingularBytesField {return false}
@@ -18215,12 +18495,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularDoubleField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularDoubleField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularDoubleField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularDoubleField) -> Bool {
     if lhs.decodeSingularDoubleField != rhs.decodeSingularDoubleField {return false}
@@ -18247,12 +18525,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularEnumField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularEnumField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularEnumField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularEnumField) -> Bool {
     if lhs.decodeSingularEnumField != rhs.decodeSingularEnumField {return false}
@@ -18279,12 +18555,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularFixed32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularFixed32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularFixed32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field) -> Bool {
     if lhs.decodeSingularFixed32Field != rhs.decodeSingularFixed32Field {return false}
@@ -18311,12 +18585,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularFixed64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularFixed64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularFixed64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field) -> Bool {
     if lhs.decodeSingularFixed64Field != rhs.decodeSingularFixed64Field {return false}
@@ -18343,12 +18615,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularFloatField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularFloatField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularFloatField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFloatField) -> Bool {
     if lhs.decodeSingularFloatField != rhs.decodeSingularFloatField {return false}
@@ -18375,12 +18645,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularGroupField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularGroupField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularGroupField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularGroupField) -> Bool {
     if lhs.decodeSingularGroupField != rhs.decodeSingularGroupField {return false}
@@ -18407,12 +18675,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularInt32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularInt32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularInt32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt32Field) -> Bool {
     if lhs.decodeSingularInt32Field != rhs.decodeSingularInt32Field {return false}
@@ -18439,12 +18705,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularInt64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularInt64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularInt64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt64Field) -> Bool {
     if lhs.decodeSingularInt64Field != rhs.decodeSingularInt64Field {return false}
@@ -18471,12 +18735,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularMessageField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularMessageField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularMessageField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularMessageField) -> Bool {
     if lhs.decodeSingularMessageField != rhs.decodeSingularMessageField {return false}
@@ -18503,12 +18765,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularSfixed32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularSfixed32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularSfixed32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field) -> Bool {
     if lhs.decodeSingularSfixed32Field != rhs.decodeSingularSfixed32Field {return false}
@@ -18535,12 +18795,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularSfixed64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularSfixed64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularSfixed64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field) -> Bool {
     if lhs.decodeSingularSfixed64Field != rhs.decodeSingularSfixed64Field {return false}
@@ -18567,12 +18825,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularSint32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularSint32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularSint32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field) -> Bool {
     if lhs.decodeSingularSint32Field != rhs.decodeSingularSint32Field {return false}
@@ -18599,12 +18855,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularSint64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularSint64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularSint64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field) -> Bool {
     if lhs.decodeSingularSint64Field != rhs.decodeSingularSint64Field {return false}
@@ -18631,12 +18885,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularStringField != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularStringField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularStringField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularStringField) -> Bool {
     if lhs.decodeSingularStringField != rhs.decodeSingularStringField {return false}
@@ -18663,12 +18915,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularUint32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularUint32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularUint32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field) -> Bool {
     if lhs.decodeSingularUint32Field != rhs.decodeSingularUint32Field {return false}
@@ -18695,12 +18945,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeSingularUint64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeSingularUint64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeSingularUint64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field) -> Bool {
     if lhs.decodeSingularUint64Field != rhs.decodeSingularUint64Field {return false}
@@ -18727,12 +18975,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeTextF
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.decodeTextFormat != 0 {
-      try visitor.visitSingularInt32Field(value: self.decodeTextFormat, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decodeTextFormat }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeTextFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeTextFormat) -> Bool {
     if lhs.decodeTextFormat != rhs.decodeTextFormat {return false}
@@ -18759,12 +19005,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultAnyT
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.defaultAnyTypeUrlprefix != 0 {
-      try visitor.visitSingularInt32Field(value: self.defaultAnyTypeUrlprefix, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.defaultAnyTypeUrlprefix }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix) -> Bool {
     if lhs.defaultAnyTypeUrlprefix != rhs.defaultAnyTypeUrlprefix {return false}
@@ -18791,12 +19035,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaults: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.defaults != 0 {
-      try visitor.visitSingularInt32Field(value: self.defaults, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.defaults }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaults, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaults) -> Bool {
     if lhs.defaults != rhs.defaults {return false}
@@ -18823,12 +19065,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultValu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.defaultValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.defaultValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.defaultValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultValue) -> Bool {
     if lhs.defaultValue != rhs.defaultValue {return false}
@@ -18855,12 +19095,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dependency:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.dependency != 0 {
-      try visitor.visitSingularInt32Field(value: self.dependency, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.dependency }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dependency) -> Bool {
     if lhs.dependency != rhs.dependency {return false}
@@ -18887,12 +19125,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecated:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.deprecated != 0 {
-      try visitor.visitSingularInt32Field(value: self.deprecated, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.deprecated }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecated) -> Bool {
     if lhs.deprecated != rhs.deprecated {return false}
@@ -18919,12 +19155,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecatedL
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.deprecatedLegacyJsonFieldConflicts != 0 {
-      try visitor.visitSingularInt32Field(value: self.deprecatedLegacyJsonFieldConflicts, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.deprecatedLegacyJsonFieldConflicts }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecatedLegacyJsonFieldConflicts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecatedLegacyJsonFieldConflicts) -> Bool {
     if lhs.deprecatedLegacyJsonFieldConflicts != rhs.deprecatedLegacyJsonFieldConflicts {return false}
@@ -18951,12 +19185,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.description
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.description_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.description_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.description_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.descriptionMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.descriptionMessage) -> Bool {
     if lhs.description_p != rhs.description_p {return false}
@@ -18983,12 +19215,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DescriptorP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.descriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.descriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.descriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DescriptorProto) -> Bool {
     if lhs.descriptorProto != rhs.descriptorProto {return false}
@@ -19015,12 +19245,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Dictionary:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.dictionary != 0 {
-      try visitor.visitSingularInt32Field(value: self.dictionary, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.dictionary }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Dictionary, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Dictionary) -> Bool {
     if lhs.dictionary != rhs.dictionary {return false}
@@ -19047,12 +19275,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dictionaryL
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.dictionaryLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.dictionaryLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.dictionaryLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dictionaryLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dictionaryLiteral) -> Bool {
     if lhs.dictionaryLiteral != rhs.dictionaryLiteral {return false}
@@ -19079,12 +19305,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.digit != 0 {
-      try visitor.visitSingularInt32Field(value: self.digit, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.digit }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit) -> Bool {
     if lhs.digit != rhs.digit {return false}
@@ -19111,12 +19335,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit0: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.digit0 != 0 {
-      try visitor.visitSingularInt32Field(value: self.digit0, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.digit0 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit0, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit0) -> Bool {
     if lhs.digit0 != rhs.digit0 {return false}
@@ -19143,12 +19365,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit1: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.digit1 != 0 {
-      try visitor.visitSingularInt32Field(value: self.digit1, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.digit1 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit1, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit1) -> Bool {
     if lhs.digit1 != rhs.digit1 {return false}
@@ -19175,12 +19395,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitCount:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.digitCount != 0 {
-      try visitor.visitSingularInt32Field(value: self.digitCount, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.digitCount }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitCount, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitCount) -> Bool {
     if lhs.digitCount != rhs.digitCount {return false}
@@ -19207,12 +19425,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digits: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.digits != 0 {
-      try visitor.visitSingularInt32Field(value: self.digits, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.digits }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digits, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digits) -> Bool {
     if lhs.digits != rhs.digits {return false}
@@ -19239,12 +19455,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitValue:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.digitValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.digitValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.digitValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitValue) -> Bool {
     if lhs.digitValue != rhs.digitValue {return false}
@@ -19271,12 +19485,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardable
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.discardableResult != 0 {
-      try visitor.visitSingularInt32Field(value: self.discardableResult, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.discardableResult }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardableResult, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardableResult) -> Bool {
     if lhs.discardableResult != rhs.discardableResult {return false}
@@ -19303,12 +19515,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardUnkn
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.discardUnknownFields != 0 {
-      try visitor.visitSingularInt32Field(value: self.discardUnknownFields, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.discardUnknownFields }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardUnknownFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardUnknownFields) -> Bool {
     if lhs.discardUnknownFields != rhs.discardUnknownFields {return false}
@@ -19335,12 +19545,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DoubleMessa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.double != 0 {
-      try visitor.visitSingularInt32Field(value: self.double, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.double }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DoubleMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DoubleMessage) -> Bool {
     if lhs.double != rhs.double {return false}
@@ -19367,12 +19575,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.doubleValue
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.doubleValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.doubleValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.doubleValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.doubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.doubleValue) -> Bool {
     if lhs.doubleValue != rhs.doubleValue {return false}
@@ -19399,12 +19605,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Duration: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.duration != 0 {
-      try visitor.visitSingularInt32Field(value: self.duration, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.duration }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Duration, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Duration) -> Bool {
     if lhs.duration != rhs.duration {return false}
@@ -19431,12 +19635,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.E: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.e != 0 {
-      try visitor.visitSingularInt32Field(value: self.e, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.e }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.E, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.E) -> Bool {
     if lhs.e != rhs.e {return false}
@@ -19463,12 +19665,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.edition: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.edition != 0 {
-      try visitor.visitSingularInt32Field(value: self.edition, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.edition }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.edition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.edition) -> Bool {
     if lhs.edition != rhs.edition {return false}
@@ -19495,12 +19695,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EditionDefa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.editionDefault != 0 {
-      try visitor.visitSingularInt32Field(value: self.editionDefault, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.editionDefault }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EditionDefault, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EditionDefault) -> Bool {
     if lhs.editionDefault != rhs.editionDefault {return false}
@@ -19527,12 +19725,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDefa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.editionDefaults != 0 {
-      try visitor.visitSingularInt32Field(value: self.editionDefaults, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.editionDefaults }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDefaults, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDefaults) -> Bool {
     if lhs.editionDefaults != rhs.editionDefaults {return false}
@@ -19559,12 +19755,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Element: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.element != 0 {
-      try visitor.visitSingularInt32Field(value: self.element, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.element }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Element, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Element) -> Bool {
     if lhs.element != rhs.element {return false}
@@ -19591,12 +19785,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elements: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.elements != 0 {
-      try visitor.visitSingularInt32Field(value: self.elements, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.elements }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elements, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elements) -> Bool {
     if lhs.elements != rhs.elements {return false}
@@ -19623,12 +19815,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitExtensi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.emitExtensionFieldName != 0 {
-      try visitor.visitSingularInt32Field(value: self.emitExtensionFieldName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.emitExtensionFieldName }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitExtensionFieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitExtensionFieldName) -> Bool {
     if lhs.emitExtensionFieldName != rhs.emitExtensionFieldName {return false}
@@ -19655,12 +19845,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldNa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.emitFieldName != 0 {
-      try visitor.visitSingularInt32Field(value: self.emitFieldName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.emitFieldName }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldName) -> Bool {
     if lhs.emitFieldName != rhs.emitFieldName {return false}
@@ -19687,12 +19875,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldNu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.emitFieldNumber != 0 {
-      try visitor.visitSingularInt32Field(value: self.emitFieldNumber, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.emitFieldNumber }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldNumber) -> Bool {
     if lhs.emitFieldNumber != rhs.emitFieldNumber {return false}
@@ -19719,12 +19905,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Empty: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.empty != 0 {
-      try visitor.visitSingularInt32Field(value: self.empty, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.empty }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Empty, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Empty) -> Bool {
     if lhs.empty != rhs.empty {return false}
@@ -19751,12 +19935,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeAsByt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.encodeAsBytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.encodeAsBytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.encodeAsBytes }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeAsBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeAsBytes) -> Bool {
     if lhs.encodeAsBytes != rhs.encodeAsBytes {return false}
@@ -19783,12 +19965,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoded: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.encoded != 0 {
-      try visitor.visitSingularInt32Field(value: self.encoded, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.encoded }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoded) -> Bool {
     if lhs.encoded != rhs.encoded {return false}
@@ -19815,12 +19995,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedJSON
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.encodedJsonstring != 0 {
-      try visitor.visitSingularInt32Field(value: self.encodedJsonstring, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.encodedJsonstring }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedJSONString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedJSONString) -> Bool {
     if lhs.encodedJsonstring != rhs.encodedJsonstring {return false}
@@ -19847,12 +20025,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedSize
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.encodedSize != 0 {
-      try visitor.visitSingularInt32Field(value: self.encodedSize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.encodedSize }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedSize) -> Bool {
     if lhs.encodedSize != rhs.encodedSize {return false}
@@ -19879,12 +20055,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeField
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.encodeField != 0 {
-      try visitor.visitSingularInt32Field(value: self.encodeField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.encodeField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeField) -> Bool {
     if lhs.encodeField != rhs.encodeField {return false}
@@ -19911,12 +20085,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoder: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.encoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.encoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.encoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoder) -> Bool {
     if lhs.encoder != rhs.encoder {return false}
@@ -19943,12 +20115,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.end: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.end != 0 {
-      try visitor.visitSingularInt32Field(value: self.end, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.end }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.end, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.end) -> Bool {
     if lhs.end != rhs.end {return false}
@@ -19975,12 +20145,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endArray: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.endArray != 0 {
-      try visitor.visitSingularInt32Field(value: self.endArray, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.endArray }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endArray, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endArray) -> Bool {
     if lhs.endArray != rhs.endArray {return false}
@@ -20007,12 +20175,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endMessageF
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.endMessageField != 0 {
-      try visitor.visitSingularInt32Field(value: self.endMessageField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.endMessageField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endMessageField) -> Bool {
     if lhs.endMessageField != rhs.endMessageField {return false}
@@ -20039,12 +20205,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endObject:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.endObject != 0 {
-      try visitor.visitSingularInt32Field(value: self.endObject, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.endObject }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endObject, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endObject) -> Bool {
     if lhs.endObject != rhs.endObject {return false}
@@ -20071,12 +20235,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endRegularF
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.endRegularField != 0 {
-      try visitor.visitSingularInt32Field(value: self.endRegularField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.endRegularField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endRegularField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endRegularField) -> Bool {
     if lhs.endRegularField != rhs.endRegularField {return false}
@@ -20103,12 +20265,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumMessage
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`enum` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`enum`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`enum` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumMessage) -> Bool {
     if lhs.`enum` != rhs.`enum` {return false}
@@ -20135,12 +20295,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumDescrip
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.enumDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.enumDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.enumDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumDescriptorProto) -> Bool {
     if lhs.enumDescriptorProto != rhs.enumDescriptorProto {return false}
@@ -20167,12 +20325,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumOptions
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.enumOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.enumOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.enumOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumOptions) -> Bool {
     if lhs.enumOptions != rhs.enumOptions {return false}
@@ -20199,12 +20355,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumReserve
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.enumReservedRange != 0 {
-      try visitor.visitSingularInt32Field(value: self.enumReservedRange, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.enumReservedRange }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumReservedRange, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumReservedRange) -> Bool {
     if lhs.enumReservedRange != rhs.enumReservedRange {return false}
@@ -20231,12 +20385,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumType: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.enumType != 0 {
-      try visitor.visitSingularInt32Field(value: self.enumType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.enumType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumType) -> Bool {
     if lhs.enumType != rhs.enumType {return false}
@@ -20263,12 +20415,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumvalue:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.enumvalue != 0 {
-      try visitor.visitSingularInt32Field(value: self.enumvalue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.enumvalue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumvalue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumvalue) -> Bool {
     if lhs.enumvalue != rhs.enumvalue {return false}
@@ -20295,12 +20445,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumValueDe
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.enumValueDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.enumValueDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.enumValueDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumValueDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumValueDescriptorProto) -> Bool {
     if lhs.enumValueDescriptorProto != rhs.enumValueDescriptorProto {return false}
@@ -20327,12 +20475,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumValueOp
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.enumValueOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.enumValueOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.enumValueOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumValueOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumValueOptions) -> Bool {
     if lhs.enumValueOptions != rhs.enumValueOptions {return false}
@@ -20359,12 +20505,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EquatableMe
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.equatable != 0 {
-      try visitor.visitSingularInt32Field(value: self.equatable, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.equatable }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EquatableMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EquatableMessage) -> Bool {
     if lhs.equatable != rhs.equatable {return false}
@@ -20391,12 +20535,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Error: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.error != 0 {
-      try visitor.visitSingularInt32Field(value: self.error, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.error }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Error, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Error) -> Bool {
     if lhs.error != rhs.error {return false}
@@ -20405,6 +20547,36 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Error: Swif
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.escaping: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".escaping"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "escaping"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.escaping) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.escaping }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.escaping, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.escaping) -> Bool {
+    if lhs.escaping != rhs.escaping {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExpressibleByArrayLiteral"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -20423,12 +20595,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Expressible
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.expressibleByArrayLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.expressibleByArrayLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.expressibleByArrayLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral) -> Bool {
     if lhs.expressibleByArrayLiteral != rhs.expressibleByArrayLiteral {return false}
@@ -20455,12 +20625,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Expressible
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.expressibleByDictionaryLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.expressibleByDictionaryLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.expressibleByDictionaryLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral) -> Bool {
     if lhs.expressibleByDictionaryLiteral != rhs.expressibleByDictionaryLiteral {return false}
@@ -20487,12 +20655,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ext: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.ext != 0 {
-      try visitor.visitSingularInt32Field(value: self.ext, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.ext }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ext) -> Bool {
     if lhs.ext != rhs.ext {return false}
@@ -20519,12 +20685,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extDecoder:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extDecoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.extDecoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extDecoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extDecoder) -> Bool {
     if lhs.extDecoder != rhs.extDecoder {return false}
@@ -20551,12 +20715,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendedGra
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extendedGraphemeClusterLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.extendedGraphemeClusterLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extendedGraphemeClusterLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral) -> Bool {
     if lhs.extendedGraphemeClusterLiteral != rhs.extendedGraphemeClusterLiteral {return false}
@@ -20583,12 +20745,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtendedGra
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extendedGraphemeClusterLiteralType != 0 {
-      try visitor.visitSingularInt32Field(value: self.extendedGraphemeClusterLiteralType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extendedGraphemeClusterLiteralType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType) -> Bool {
     if lhs.extendedGraphemeClusterLiteralType != rhs.extendedGraphemeClusterLiteralType {return false}
@@ -20615,12 +20775,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendee: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extendee != 0 {
-      try visitor.visitSingularInt32Field(value: self.extendee, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extendee }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendee, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendee) -> Bool {
     if lhs.extendee != rhs.extendee {return false}
@@ -20647,12 +20805,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensibleM
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extensibleMessage != 0 {
-      try visitor.visitSingularInt32Field(value: self.extensibleMessage, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensibleMessage }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensibleMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensibleMessage) -> Bool {
     if lhs.extensibleMessage != rhs.extensibleMessage {return false}
@@ -20679,12 +20835,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionMe
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`extension` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`extension`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`extension` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionMessage) -> Bool {
     if lhs.`extension` != rhs.`extension` {return false}
@@ -20711,12 +20865,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.extensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionField) -> Bool {
     if lhs.extensionField != rhs.extensionField {return false}
@@ -20743,12 +20895,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extensionFieldNumber != 0 {
-      try visitor.visitSingularInt32Field(value: self.extensionFieldNumber, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensionFieldNumber }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldNumber) -> Bool {
     if lhs.extensionFieldNumber != rhs.extensionFieldNumber {return false}
@@ -20757,6 +20907,66 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFi
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extensionFields"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "extensionFields"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionFields) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensionFields }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFields) -> Bool {
+    if lhs.extensionFields != rhs.extensionFields {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldsAsMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extensionFieldsAsMessageSet"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "extensionFieldsAsMessageSet"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionFieldsAsMessageSet) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensionFieldsAsMessageSet }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldsAsMessageSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldsAsMessageSet) -> Bool {
+    if lhs.extensionFieldsAsMessageSet != rhs.extensionFieldsAsMessageSet {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionFieldValueSet"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -20775,12 +20985,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extensionFieldValueSet != 0 {
-      try visitor.visitSingularInt32Field(value: self.extensionFieldValueSet, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensionFieldValueSet }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet) -> Bool {
     if lhs.extensionFieldValueSet != rhs.extensionFieldValueSet {return false}
@@ -20807,12 +21015,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionMa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extensionMap != 0 {
-      try visitor.visitSingularInt32Field(value: self.extensionMap, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensionMap }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionMap) -> Bool {
     if lhs.extensionMap != rhs.extensionMap {return false}
@@ -20839,12 +21045,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionRa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extensionRange != 0 {
-      try visitor.visitSingularInt32Field(value: self.extensionRange, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensionRange }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionRange, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionRange) -> Bool {
     if lhs.extensionRange != rhs.extensionRange {return false}
@@ -20871,12 +21075,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionRa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extensionRangeOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.extensionRangeOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensionRangeOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionRangeOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionRangeOptions) -> Bool {
     if lhs.extensionRangeOptions != rhs.extensionRangeOptions {return false}
@@ -20903,12 +21105,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensions:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extensions != 0 {
-      try visitor.visitSingularInt32Field(value: self.extensions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensions) -> Bool {
     if lhs.extensions != rhs.extensions {return false}
@@ -20935,12 +21135,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extras: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.extras != 0 {
-      try visitor.visitSingularInt32Field(value: self.extras, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extras }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extras, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extras) -> Bool {
     if lhs.extras != rhs.extras {return false}
@@ -20967,12 +21165,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.F: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.f != 0 {
-      try visitor.visitSingularInt32Field(value: self.f, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.f }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.F, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.F) -> Bool {
     if lhs.f != rhs.f {return false}
@@ -20999,12 +21195,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.falseMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`false` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`false`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`false` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.falseMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.falseMessage) -> Bool {
     if lhs.`false` != rhs.`false` {return false}
@@ -21031,12 +21225,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.features: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.features != 0 {
-      try visitor.visitSingularInt32Field(value: self.features, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.features }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.features, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.features) -> Bool {
     if lhs.features != rhs.features {return false}
@@ -21063,12 +21255,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSet:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.featureSet != 0 {
-      try visitor.visitSingularInt32Field(value: self.featureSet, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.featureSet }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSet) -> Bool {
     if lhs.featureSet != rhs.featureSet {return false}
@@ -21095,12 +21285,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetD
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.featureSetDefaults != 0 {
-      try visitor.visitSingularInt32Field(value: self.featureSetDefaults, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.featureSetDefaults }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetDefaults, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetDefaults) -> Bool {
     if lhs.featureSetDefaults != rhs.featureSetDefaults {return false}
@@ -21127,12 +21315,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetE
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.featureSetEditionDefault != 0 {
-      try visitor.visitSingularInt32Field(value: self.featureSetEditionDefault, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.featureSetEditionDefault }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetEditionDefault, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetEditionDefault) -> Bool {
     if lhs.featureSetEditionDefault != rhs.featureSetEditionDefault {return false}
@@ -21159,12 +21345,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.field: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.field != 0 {
-      try visitor.visitSingularInt32Field(value: self.field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.field) -> Bool {
     if lhs.field != rhs.field {return false}
@@ -21191,12 +21375,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldData:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldData != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldData, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldData }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldData) -> Bool {
     if lhs.fieldData != rhs.fieldData {return false}
@@ -21223,12 +21405,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldDescri
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldDescriptorProto) -> Bool {
     if lhs.fieldDescriptorProto != rhs.fieldDescriptorProto {return false}
@@ -21255,12 +21435,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldMask:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldMask != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldMask, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldMask }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldMask, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldMask) -> Bool {
     if lhs.fieldMask != rhs.fieldMask {return false}
@@ -21287,12 +21465,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldName:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldName != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldName }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldName) -> Bool {
     if lhs.fieldName != rhs.fieldName {return false}
@@ -21319,12 +21495,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNameCo
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldNameCount != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldNameCount, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldNameCount }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNameCount, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNameCount) -> Bool {
     if lhs.fieldNameCount != rhs.fieldNameCount {return false}
@@ -21351,12 +21525,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNum: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldNum != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldNum, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldNum }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNum) -> Bool {
     if lhs.fieldNum != rhs.fieldNum {return false}
@@ -21383,12 +21555,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumber
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldNumber != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldNumber, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldNumber }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumber) -> Bool {
     if lhs.fieldNumber != rhs.fieldNumber {return false}
@@ -21415,12 +21585,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumber
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldNumberForProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldNumberForProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldNumberForProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumberForProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumberForProto) -> Bool {
     if lhs.fieldNumberForProto != rhs.fieldNumberForProto {return false}
@@ -21447,12 +21615,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldOption
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldOptions) -> Bool {
     if lhs.fieldOptions != rhs.fieldOptions {return false}
@@ -21479,12 +21645,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldPresen
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldPresence != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldPresence, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldPresence }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldPresence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldPresence) -> Bool {
     if lhs.fieldPresence != rhs.fieldPresence {return false}
@@ -21511,12 +21675,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fields: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fields != 0 {
-      try visitor.visitSingularInt32Field(value: self.fields, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fields }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fields) -> Bool {
     if lhs.fields != rhs.fields {return false}
@@ -21543,12 +21705,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldSize:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldSize != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldSize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldSize }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldSize) -> Bool {
     if lhs.fieldSize != rhs.fieldSize {return false}
@@ -21575,12 +21735,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldTag: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldTag != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldTag, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldTag }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldTag, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldTag) -> Bool {
     if lhs.fieldTag != rhs.fieldTag {return false}
@@ -21607,12 +21765,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldType:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fieldType != 0 {
-      try visitor.visitSingularInt32Field(value: self.fieldType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fieldType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldType) -> Bool {
     if lhs.fieldType != rhs.fieldType {return false}
@@ -21639,12 +21795,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.file: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.file != 0 {
-      try visitor.visitSingularInt32Field(value: self.file, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.file }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.file, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.file) -> Bool {
     if lhs.file != rhs.file {return false}
@@ -21671,12 +21825,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FileDescrip
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fileDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.fileDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fileDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FileDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FileDescriptorProto) -> Bool {
     if lhs.fileDescriptorProto != rhs.fileDescriptorProto {return false}
@@ -21703,12 +21855,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FileDescrip
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fileDescriptorSet != 0 {
-      try visitor.visitSingularInt32Field(value: self.fileDescriptorSet, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fileDescriptorSet }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FileDescriptorSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FileDescriptorSet) -> Bool {
     if lhs.fileDescriptorSet != rhs.fileDescriptorSet {return false}
@@ -21735,12 +21885,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fileName: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fileName != 0 {
-      try visitor.visitSingularInt32Field(value: self.fileName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fileName }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fileName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fileName) -> Bool {
     if lhs.fileName != rhs.fileName {return false}
@@ -21767,12 +21915,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FileOptions
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fileOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.fileOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fileOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FileOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FileOptions) -> Bool {
     if lhs.fileOptions != rhs.fileOptions {return false}
@@ -21799,12 +21945,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.filter: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.filter != 0 {
-      try visitor.visitSingularInt32Field(value: self.filter, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.filter }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.filter, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.filter) -> Bool {
     if lhs.filter != rhs.filter {return false}
@@ -21831,12 +21975,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.final: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.final != 0 {
-      try visitor.visitSingularInt32Field(value: self.final, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.final }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.final, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.final) -> Bool {
     if lhs.final != rhs.final {return false}
@@ -21863,12 +22005,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.first: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.first != 0 {
-      try visitor.visitSingularInt32Field(value: self.first, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.first }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.first, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.first) -> Bool {
     if lhs.first != rhs.first {return false}
@@ -21895,12 +22035,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.firstItem:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.firstItem != 0 {
-      try visitor.visitSingularInt32Field(value: self.firstItem, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.firstItem }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.firstItem, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.firstItem) -> Bool {
     if lhs.firstItem != rhs.firstItem {return false}
@@ -21927,12 +22065,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.float != 0 {
-      try visitor.visitSingularInt32Field(value: self.float, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.float }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatMessage) -> Bool {
     if lhs.float != rhs.float {return false}
@@ -21959,12 +22095,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.floatLitera
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.floatLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.floatLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.floatLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.floatLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.floatLiteral) -> Bool {
     if lhs.floatLiteral != rhs.floatLiteral {return false}
@@ -21991,12 +22125,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatLitera
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.floatLiteralType != 0 {
-      try visitor.visitSingularInt32Field(value: self.floatLiteralType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.floatLiteralType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatLiteralType) -> Bool {
     if lhs.floatLiteralType != rhs.floatLiteralType {return false}
@@ -22023,12 +22155,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatValue:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.floatValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.floatValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.floatValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatValue) -> Bool {
     if lhs.floatValue != rhs.floatValue {return false}
@@ -22055,12 +22185,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessageN
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.forMessageName != 0 {
-      try visitor.visitSingularInt32Field(value: self.forMessageName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.forMessageName }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessageName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessageName) -> Bool {
     if lhs.forMessageName != rhs.forMessageName {return false}
@@ -22087,12 +22215,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.formUnion:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.formUnion != 0 {
-      try visitor.visitSingularInt32Field(value: self.formUnion, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.formUnion }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.formUnion, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.formUnion) -> Bool {
     if lhs.formUnion != rhs.formUnion {return false}
@@ -22119,12 +22245,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forReadingF
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.forReadingFrom != 0 {
-      try visitor.visitSingularInt32Field(value: self.forReadingFrom, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.forReadingFrom }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forReadingFrom, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forReadingFrom) -> Bool {
     if lhs.forReadingFrom != rhs.forReadingFrom {return false}
@@ -22151,12 +22275,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forTypeURL:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.forTypeURL != 0 {
-      try visitor.visitSingularInt32Field(value: self.forTypeURL, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.forTypeURL }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forTypeURL) -> Bool {
     if lhs.forTypeURL != rhs.forTypeURL {return false}
@@ -22183,12 +22305,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ForwardPars
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.forwardParser != 0 {
-      try visitor.visitSingularInt32Field(value: self.forwardParser, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.forwardParser }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ForwardParser, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ForwardParser) -> Bool {
     if lhs.forwardParser != rhs.forwardParser {return false}
@@ -22215,12 +22335,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forWritingI
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.forWritingInto != 0 {
-      try visitor.visitSingularInt32Field(value: self.forWritingInto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.forWritingInto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forWritingInto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forWritingInto) -> Bool {
     if lhs.forWritingInto != rhs.forWritingInto {return false}
@@ -22247,12 +22365,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.from: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.from != 0 {
-      try visitor.visitSingularInt32Field(value: self.from, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.from }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.from, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.from) -> Bool {
     if lhs.from != rhs.from {return false}
@@ -22279,12 +22395,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii2:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fromAscii2 != 0 {
-      try visitor.visitSingularInt32Field(value: self.fromAscii2, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fromAscii2 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii2, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii2) -> Bool {
     if lhs.fromAscii2 != rhs.fromAscii2 {return false}
@@ -22311,12 +22425,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii4:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fromAscii4 != 0 {
-      try visitor.visitSingularInt32Field(value: self.fromAscii4, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fromAscii4 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii4, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii4) -> Bool {
     if lhs.fromAscii4 != rhs.fromAscii4 {return false}
@@ -22343,12 +22455,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromByteOff
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fromByteOffset != 0 {
-      try visitor.visitSingularInt32Field(value: self.fromByteOffset, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fromByteOffset }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromByteOffset, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromByteOffset) -> Bool {
     if lhs.fromByteOffset != rhs.fromByteOffset {return false}
@@ -22375,12 +22485,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromHexDigi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fromHexDigit != 0 {
-      try visitor.visitSingularInt32Field(value: self.fromHexDigit, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fromHexDigit }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromHexDigit, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromHexDigit) -> Bool {
     if lhs.fromHexDigit != rhs.fromHexDigit {return false}
@@ -22407,12 +22515,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fullName: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.fullName != 0 {
-      try visitor.visitSingularInt32Field(value: self.fullName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fullName }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fullName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fullName) -> Bool {
     if lhs.fullName != rhs.fullName {return false}
@@ -22439,12 +22545,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.funcMessage
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`func` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`func`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`func` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.funcMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.funcMessage) -> Bool {
     if lhs.`func` != rhs.`func` {return false}
@@ -22471,12 +22575,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.G: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.g != 0 {
-      try visitor.visitSingularInt32Field(value: self.g, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.g }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.G, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.G) -> Bool {
     if lhs.g != rhs.g {return false}
@@ -22503,12 +22605,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.GeneratedCo
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.generatedCodeInfo != 0 {
-      try visitor.visitSingularInt32Field(value: self.generatedCodeInfo, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.generatedCodeInfo }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.GeneratedCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.GeneratedCodeInfo) -> Bool {
     if lhs.generatedCodeInfo != rhs.generatedCodeInfo {return false}
@@ -22535,12 +22635,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.get: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.get != 0 {
-      try visitor.visitSingularInt32Field(value: self.get, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.get }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.get, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.get) -> Bool {
     if lhs.get != rhs.get {return false}
@@ -22567,12 +22665,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getExtensio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.getExtensionValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.getExtensionValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.getExtensionValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getExtensionValue) -> Bool {
     if lhs.getExtensionValue != rhs.getExtensionValue {return false}
@@ -22581,6 +22677,36 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getExtensio
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".getValue"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "getValue"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.getValue) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.getValue }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getValue) -> Bool {
+    if lhs.getValue != rhs.getValue {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.googleapis: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".googleapis"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -22599,12 +22725,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.googleapis:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleapis != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleapis, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleapis }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.googleapis, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.googleapis) -> Bool {
     if lhs.googleapis != rhs.googleapis {return false}
@@ -22631,12 +22755,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufAny != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufAny, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufAny }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Any, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Any) -> Bool {
     if lhs.googleProtobufAny != rhs.googleProtobufAny {return false}
@@ -22663,12 +22785,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufApi != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufApi, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufApi }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Api, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Api) -> Bool {
     if lhs.googleProtobufApi != rhs.googleProtobufApi {return false}
@@ -22695,12 +22815,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufBoolValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufBoolValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufBoolValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue) -> Bool {
     if lhs.googleProtobufBoolValue != rhs.googleProtobufBoolValue {return false}
@@ -22727,12 +22845,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufBytesValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufBytesValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufBytesValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue) -> Bool {
     if lhs.googleProtobufBytesValue != rhs.googleProtobufBytesValue {return false}
@@ -22759,12 +22875,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto) -> Bool {
     if lhs.googleProtobufDescriptorProto != rhs.googleProtobufDescriptorProto {return false}
@@ -22791,12 +22905,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufDoubleValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufDoubleValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufDoubleValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue) -> Bool {
     if lhs.googleProtobufDoubleValue != rhs.googleProtobufDoubleValue {return false}
@@ -22823,12 +22935,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufDuration != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufDuration, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufDuration }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration) -> Bool {
     if lhs.googleProtobufDuration != rhs.googleProtobufDuration {return false}
@@ -22855,12 +22965,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufEdition != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufEdition, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufEdition }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Edition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Edition) -> Bool {
     if lhs.googleProtobufEdition != rhs.googleProtobufEdition {return false}
@@ -22887,12 +22995,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufEmpty != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufEmpty, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufEmpty }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty) -> Bool {
     if lhs.googleProtobufEmpty != rhs.googleProtobufEmpty {return false}
@@ -22919,12 +23025,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufEnum != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufEnum, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufEnum }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum) -> Bool {
     if lhs.googleProtobufEnum != rhs.googleProtobufEnum {return false}
@@ -22951,12 +23055,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufEnumDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufEnumDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufEnumDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto) -> Bool {
     if lhs.googleProtobufEnumDescriptorProto != rhs.googleProtobufEnumDescriptorProto {return false}
@@ -22983,12 +23085,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufEnumOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufEnumOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufEnumOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions) -> Bool {
     if lhs.googleProtobufEnumOptions != rhs.googleProtobufEnumOptions {return false}
@@ -23015,12 +23115,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufEnumValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufEnumValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue) -> Bool {
     if lhs.googleProtobufEnumValue != rhs.googleProtobufEnumValue {return false}
@@ -23047,12 +23145,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufEnumValueDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValueDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufEnumValueDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto) -> Bool {
     if lhs.googleProtobufEnumValueDescriptorProto != rhs.googleProtobufEnumValueDescriptorProto {return false}
@@ -23079,12 +23175,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufEnumValueOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValueOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufEnumValueOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions) -> Bool {
     if lhs.googleProtobufEnumValueOptions != rhs.googleProtobufEnumValueOptions {return false}
@@ -23111,12 +23205,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufExtensionRangeOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufExtensionRangeOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufExtensionRangeOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions) -> Bool {
     if lhs.googleProtobufExtensionRangeOptions != rhs.googleProtobufExtensionRangeOptions {return false}
@@ -23143,12 +23235,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufFeatureSet != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufFeatureSet, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufFeatureSet }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSet) -> Bool {
     if lhs.googleProtobufFeatureSet != rhs.googleProtobufFeatureSet {return false}
@@ -23175,12 +23265,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufFeatureSetDefaults != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufFeatureSetDefaults, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufFeatureSetDefaults }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSetDefaults, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSetDefaults) -> Bool {
     if lhs.googleProtobufFeatureSetDefaults != rhs.googleProtobufFeatureSetDefaults {return false}
@@ -23207,12 +23295,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufField != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Field) -> Bool {
     if lhs.googleProtobufField != rhs.googleProtobufField {return false}
@@ -23239,12 +23325,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufFieldDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufFieldDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufFieldDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto) -> Bool {
     if lhs.googleProtobufFieldDescriptorProto != rhs.googleProtobufFieldDescriptorProto {return false}
@@ -23271,12 +23355,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufFieldMask != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufFieldMask, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufFieldMask }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask) -> Bool {
     if lhs.googleProtobufFieldMask != rhs.googleProtobufFieldMask {return false}
@@ -23303,12 +23385,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufFieldOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufFieldOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufFieldOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions) -> Bool {
     if lhs.googleProtobufFieldOptions != rhs.googleProtobufFieldOptions {return false}
@@ -23335,12 +23415,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufFileDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufFileDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufFileDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto) -> Bool {
     if lhs.googleProtobufFileDescriptorProto != rhs.googleProtobufFileDescriptorProto {return false}
@@ -23367,12 +23445,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufFileDescriptorSet != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufFileDescriptorSet, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufFileDescriptorSet }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet) -> Bool {
     if lhs.googleProtobufFileDescriptorSet != rhs.googleProtobufFileDescriptorSet {return false}
@@ -23399,12 +23475,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufFileOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufFileOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufFileOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions) -> Bool {
     if lhs.googleProtobufFileOptions != rhs.googleProtobufFileOptions {return false}
@@ -23431,12 +23505,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufFloatValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufFloatValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufFloatValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue) -> Bool {
     if lhs.googleProtobufFloatValue != rhs.googleProtobufFloatValue {return false}
@@ -23463,12 +23535,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufGeneratedCodeInfo != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufGeneratedCodeInfo, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufGeneratedCodeInfo }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo) -> Bool {
     if lhs.googleProtobufGeneratedCodeInfo != rhs.googleProtobufGeneratedCodeInfo {return false}
@@ -23495,12 +23565,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufInt32Value != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufInt32Value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufInt32Value }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value) -> Bool {
     if lhs.googleProtobufInt32Value != rhs.googleProtobufInt32Value {return false}
@@ -23527,12 +23595,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufInt64Value != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufInt64Value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufInt64Value }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value) -> Bool {
     if lhs.googleProtobufInt64Value != rhs.googleProtobufInt64Value {return false}
@@ -23559,12 +23625,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufListValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufListValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufListValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue) -> Bool {
     if lhs.googleProtobufListValue != rhs.googleProtobufListValue {return false}
@@ -23591,12 +23655,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufMessageOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufMessageOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufMessageOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions) -> Bool {
     if lhs.googleProtobufMessageOptions != rhs.googleProtobufMessageOptions {return false}
@@ -23623,12 +23685,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufMethod != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufMethod, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufMethod }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Method, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Method) -> Bool {
     if lhs.googleProtobufMethod != rhs.googleProtobufMethod {return false}
@@ -23655,12 +23715,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufMethodDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufMethodDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufMethodDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto) -> Bool {
     if lhs.googleProtobufMethodDescriptorProto != rhs.googleProtobufMethodDescriptorProto {return false}
@@ -23687,12 +23745,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufMethodOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufMethodOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufMethodOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions) -> Bool {
     if lhs.googleProtobufMethodOptions != rhs.googleProtobufMethodOptions {return false}
@@ -23719,12 +23775,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufMixin != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufMixin, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufMixin }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin) -> Bool {
     if lhs.googleProtobufMixin != rhs.googleProtobufMixin {return false}
@@ -23751,12 +23805,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufNullValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufNullValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufNullValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue) -> Bool {
     if lhs.googleProtobufNullValue != rhs.googleProtobufNullValue {return false}
@@ -23783,12 +23835,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufOneofDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufOneofDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufOneofDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto) -> Bool {
     if lhs.googleProtobufOneofDescriptorProto != rhs.googleProtobufOneofDescriptorProto {return false}
@@ -23815,12 +23865,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufOneofOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufOneofOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufOneofOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions) -> Bool {
     if lhs.googleProtobufOneofOptions != rhs.googleProtobufOneofOptions {return false}
@@ -23847,12 +23895,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufOption != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufOption, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufOption }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Option, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Option) -> Bool {
     if lhs.googleProtobufOption != rhs.googleProtobufOption {return false}
@@ -23879,12 +23925,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufServiceDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufServiceDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufServiceDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto) -> Bool {
     if lhs.googleProtobufServiceDescriptorProto != rhs.googleProtobufServiceDescriptorProto {return false}
@@ -23911,12 +23955,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufServiceOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufServiceOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufServiceOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions) -> Bool {
     if lhs.googleProtobufServiceOptions != rhs.googleProtobufServiceOptions {return false}
@@ -23943,12 +23985,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufSourceCodeInfo != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufSourceCodeInfo, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufSourceCodeInfo }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo) -> Bool {
     if lhs.googleProtobufSourceCodeInfo != rhs.googleProtobufSourceCodeInfo {return false}
@@ -23975,12 +24015,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufSourceContext != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufSourceContext, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufSourceContext }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext) -> Bool {
     if lhs.googleProtobufSourceContext != rhs.googleProtobufSourceContext {return false}
@@ -24007,12 +24045,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufStringValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufStringValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufStringValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue) -> Bool {
     if lhs.googleProtobufStringValue != rhs.googleProtobufStringValue {return false}
@@ -24039,12 +24075,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufStruct != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufStruct, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufStruct }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct) -> Bool {
     if lhs.googleProtobufStruct != rhs.googleProtobufStruct {return false}
@@ -24071,12 +24105,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufSyntax != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufSyntax, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufSyntax }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax) -> Bool {
     if lhs.googleProtobufSyntax != rhs.googleProtobufSyntax {return false}
@@ -24103,12 +24135,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufTimestamp != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufTimestamp, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufTimestamp }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp) -> Bool {
     if lhs.googleProtobufTimestamp != rhs.googleProtobufTimestamp {return false}
@@ -24135,12 +24165,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufType != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Type, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Type) -> Bool {
     if lhs.googleProtobufType != rhs.googleProtobufType {return false}
@@ -24167,12 +24195,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufUint32Value != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufUint32Value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufUint32Value }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value) -> Bool {
     if lhs.googleProtobufUint32Value != rhs.googleProtobufUint32Value {return false}
@@ -24199,12 +24225,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufUint64Value != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufUint64Value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufUint64Value }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value) -> Bool {
     if lhs.googleProtobufUint64Value != rhs.googleProtobufUint64Value {return false}
@@ -24231,12 +24255,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufUninterpretedOption != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufUninterpretedOption, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufUninterpretedOption }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption) -> Bool {
     if lhs.googleProtobufUninterpretedOption != rhs.googleProtobufUninterpretedOption {return false}
@@ -24263,12 +24285,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Prot
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.googleProtobufValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.googleProtobufValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.googleProtobufValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Value) -> Bool {
     if lhs.googleProtobufValue != rhs.googleProtobufValue {return false}
@@ -24295,12 +24315,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.goPackage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.goPackage != 0 {
-      try visitor.visitSingularInt32Field(value: self.goPackage, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.goPackage }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.goPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.goPackage) -> Bool {
     if lhs.goPackage != rhs.goPackage {return false}
@@ -24327,12 +24345,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.group: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.group != 0 {
-      try visitor.visitSingularInt32Field(value: self.group, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.group }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.group, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.group) -> Bool {
     if lhs.group != rhs.group {return false}
@@ -24359,12 +24375,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupFieldN
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.groupFieldNumberStack != 0 {
-      try visitor.visitSingularInt32Field(value: self.groupFieldNumberStack, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupFieldNumberStack }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupFieldNumberStack, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupFieldNumberStack) -> Bool {
     if lhs.groupFieldNumberStack != rhs.groupFieldNumberStack {return false}
@@ -24391,12 +24405,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupSize:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.groupSize != 0 {
-      try visitor.visitSingularInt32Field(value: self.groupSize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.groupSize }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupSize) -> Bool {
     if lhs.groupSize != rhs.groupSize {return false}
@@ -24423,12 +24435,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hadOneofVal
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hadOneofValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.hadOneofValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hadOneofValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hadOneofValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hadOneofValue) -> Bool {
     if lhs.hadOneofValue != rhs.hadOneofValue {return false}
@@ -24455,12 +24465,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleConfl
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.handleConflictingOneOf != 0 {
-      try visitor.visitSingularInt32Field(value: self.handleConflictingOneOf, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.handleConflictingOneOf }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleConflictingOneOf, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleConflictingOneOf) -> Bool {
     if lhs.handleConflictingOneOf != rhs.handleConflictingOneOf {return false}
@@ -24487,12 +24495,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAggregat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasAggregateValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasAggregateValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasAggregateValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAggregateValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAggregateValue) -> Bool {
     if lhs.hasAggregateValue_p != rhs.hasAggregateValue_p {return false}
@@ -24519,12 +24525,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAllowAli
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasAllowAlias_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasAllowAlias_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasAllowAlias_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAllowAlias, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAllowAlias) -> Bool {
     if lhs.hasAllowAlias_p != rhs.hasAllowAlias_p {return false}
@@ -24551,12 +24555,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasBegin: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasBegin_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasBegin_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasBegin_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasBegin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasBegin) -> Bool {
     if lhs.hasBegin_p != rhs.hasBegin_p {return false}
@@ -24583,12 +24585,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcEnable
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasCcEnableArenas_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasCcEnableArenas_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasCcEnableArenas_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcEnableArenas, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcEnableArenas) -> Bool {
     if lhs.hasCcEnableArenas_p != rhs.hasCcEnableArenas_p {return false}
@@ -24615,12 +24615,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcGeneri
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasCcGenericServices_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasCcGenericServices_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasCcGenericServices_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcGenericServices) -> Bool {
     if lhs.hasCcGenericServices_p != rhs.hasCcGenericServices_p {return false}
@@ -24647,12 +24645,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasClientSt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasClientStreaming_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasClientStreaming_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasClientStreaming_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasClientStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasClientStreaming) -> Bool {
     if lhs.hasClientStreaming_p != rhs.hasClientStreaming_p {return false}
@@ -24679,12 +24675,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCsharpNa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasCsharpNamespace_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasCsharpNamespace_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasCsharpNamespace_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCsharpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCsharpNamespace) -> Bool {
     if lhs.hasCsharpNamespace_p != rhs.hasCsharpNamespace_p {return false}
@@ -24711,12 +24705,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCtype: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasCtype_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasCtype_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasCtype_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCtype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCtype) -> Bool {
     if lhs.hasCtype_p != rhs.hasCtype_p {return false}
@@ -24743,12 +24735,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDebugRed
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasDebugRedact_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasDebugRedact_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasDebugRedact_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDebugRedact, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDebugRedact) -> Bool {
     if lhs.hasDebugRedact_p != rhs.hasDebugRedact_p {return false}
@@ -24775,12 +24765,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultV
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasDefaultValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasDefaultValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasDefaultValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultValue) -> Bool {
     if lhs.hasDefaultValue_p != rhs.hasDefaultValue_p {return false}
@@ -24807,12 +24795,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasDeprecated_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasDeprecated_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasDeprecated_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecated) -> Bool {
     if lhs.hasDeprecated_p != rhs.hasDeprecated_p {return false}
@@ -24839,12 +24825,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasDeprecatedLegacyJsonFieldConflicts_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasDeprecatedLegacyJsonFieldConflicts_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecatedLegacyJsonFieldConflicts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecatedLegacyJsonFieldConflicts) -> Bool {
     if lhs.hasDeprecatedLegacyJsonFieldConflicts_p != rhs.hasDeprecatedLegacyJsonFieldConflicts_p {return false}
@@ -24871,12 +24855,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDoubleVa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasDoubleValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasDoubleValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasDoubleValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDoubleValue) -> Bool {
     if lhs.hasDoubleValue_p != rhs.hasDoubleValue_p {return false}
@@ -24903,12 +24885,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEdition:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasEdition_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasEdition_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasEdition_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEdition) -> Bool {
     if lhs.hasEdition_p != rhs.hasEdition_p {return false}
@@ -24935,12 +24915,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnd: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasEnd_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasEnd_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasEnd_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnd, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnd) -> Bool {
     if lhs.hasEnd_p != rhs.hasEnd_p {return false}
@@ -24967,12 +24945,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnumType
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasEnumType_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasEnumType_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasEnumType_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnumType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnumType) -> Bool {
     if lhs.hasEnumType_p != rhs.hasEnumType_p {return false}
@@ -24999,12 +24975,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtendee
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasExtendee_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasExtendee_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasExtendee_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtendee, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtendee) -> Bool {
     if lhs.hasExtendee_p != rhs.hasExtendee_p {return false}
@@ -25031,12 +25005,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtensio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasExtensionValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasExtensionValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasExtensionValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtensionValue) -> Bool {
     if lhs.hasExtensionValue_p != rhs.hasExtensionValue_p {return false}
@@ -25063,12 +25035,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatures
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasFeatures_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasFeatures_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasFeatures_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatures) -> Bool {
     if lhs.hasFeatures_p != rhs.hasFeatures_p {return false}
@@ -25095,12 +25065,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFieldPre
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasFieldPresence_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasFieldPresence_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasFieldPresence_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFieldPresence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFieldPresence) -> Bool {
     if lhs.hasFieldPresence_p != rhs.hasFieldPresence_p {return false}
@@ -25127,12 +25095,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFullName
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasFullName_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasFullName_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasFullName_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFullName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFullName) -> Bool {
     if lhs.hasFullName_p != rhs.hasFullName_p {return false}
@@ -25159,12 +25125,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasGoPackag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasGoPackage_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasGoPackage_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasGoPackage_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasGoPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasGoPackage) -> Bool {
     if lhs.hasGoPackage_p != rhs.hasGoPackage_p {return false}
@@ -25191,12 +25155,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hash: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hash != 0 {
-      try visitor.visitSingularInt32Field(value: self.hash, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hash }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hash) -> Bool {
     if lhs.hash != rhs.hash {return false}
@@ -25223,12 +25185,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashableMes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hashable != 0 {
-      try visitor.visitSingularInt32Field(value: self.hashable, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hashable }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashableMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashableMessage) -> Bool {
     if lhs.hashable != rhs.hashable {return false}
@@ -25255,12 +25215,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasher: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasher != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasher, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasher }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasher, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasher) -> Bool {
     if lhs.hasher != rhs.hasher {return false}
@@ -25287,12 +25245,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashVisitor
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hashVisitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.hashVisitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hashVisitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashVisitor) -> Bool {
     if lhs.hashVisitor != rhs.hashVisitor {return false}
@@ -25319,12 +25275,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdempote
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasIdempotencyLevel_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasIdempotencyLevel_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasIdempotencyLevel_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdempotencyLevel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdempotencyLevel) -> Bool {
     if lhs.hasIdempotencyLevel_p != rhs.hasIdempotencyLevel_p {return false}
@@ -25351,12 +25305,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdentifi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasIdentifierValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasIdentifierValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasIdentifierValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdentifierValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdentifierValue) -> Bool {
     if lhs.hasIdentifierValue_p != rhs.hasIdentifierValue_p {return false}
@@ -25383,12 +25335,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasInputTyp
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasInputType_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasInputType_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasInputType_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasInputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasInputType) -> Bool {
     if lhs.hasInputType_p != rhs.hasInputType_p {return false}
@@ -25415,12 +25365,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIsExtens
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasIsExtension_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasIsExtension_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasIsExtension_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIsExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIsExtension) -> Bool {
     if lhs.hasIsExtension_p != rhs.hasIsExtension_p {return false}
@@ -25447,12 +25395,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGene
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasJavaGenerateEqualsAndHash_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasJavaGenerateEqualsAndHash_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasJavaGenerateEqualsAndHash_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash) -> Bool {
     if lhs.hasJavaGenerateEqualsAndHash_p != rhs.hasJavaGenerateEqualsAndHash_p {return false}
@@ -25479,12 +25425,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGene
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasJavaGenericServices_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasJavaGenericServices_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasJavaGenericServices_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenericServices) -> Bool {
     if lhs.hasJavaGenericServices_p != rhs.hasJavaGenericServices_p {return false}
@@ -25511,12 +25455,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaMult
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasJavaMultipleFiles_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasJavaMultipleFiles_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasJavaMultipleFiles_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles) -> Bool {
     if lhs.hasJavaMultipleFiles_p != rhs.hasJavaMultipleFiles_p {return false}
@@ -25543,12 +25485,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaOute
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasJavaOuterClassname_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasJavaOuterClassname_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasJavaOuterClassname_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaOuterClassname, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaOuterClassname) -> Bool {
     if lhs.hasJavaOuterClassname_p != rhs.hasJavaOuterClassname_p {return false}
@@ -25575,12 +25515,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaPack
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasJavaPackage_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasJavaPackage_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasJavaPackage_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaPackage) -> Bool {
     if lhs.hasJavaPackage_p != rhs.hasJavaPackage_p {return false}
@@ -25607,12 +25545,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaStri
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasJavaStringCheckUtf8_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasJavaStringCheckUtf8_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasJavaStringCheckUtf8_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8) -> Bool {
     if lhs.hasJavaStringCheckUtf8_p != rhs.hasJavaStringCheckUtf8_p {return false}
@@ -25639,12 +25575,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonForm
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasJsonFormat_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasJsonFormat_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasJsonFormat_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonFormat) -> Bool {
     if lhs.hasJsonFormat_p != rhs.hasJsonFormat_p {return false}
@@ -25671,12 +25605,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonName
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasJsonName_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasJsonName_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasJsonName_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonName) -> Bool {
     if lhs.hasJsonName_p != rhs.hasJsonName_p {return false}
@@ -25703,12 +25635,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJstype:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasJstype_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasJstype_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasJstype_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJstype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJstype) -> Bool {
     if lhs.hasJstype_p != rhs.hasJstype_p {return false}
@@ -25735,12 +25665,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLabel: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasLabel_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasLabel_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasLabel_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLabel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLabel) -> Bool {
     if lhs.hasLabel_p != rhs.hasLabel_p {return false}
@@ -25767,12 +25695,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLazy: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasLazy_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasLazy_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasLazy_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLazy) -> Bool {
     if lhs.hasLazy_p != rhs.hasLazy_p {return false}
@@ -25799,12 +25725,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLeadingC
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasLeadingComments_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasLeadingComments_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasLeadingComments_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLeadingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLeadingComments) -> Bool {
     if lhs.hasLeadingComments_p != rhs.hasLeadingComments_p {return false}
@@ -25831,12 +25755,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMapEntry
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasMapEntry_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasMapEntry_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasMapEntry_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMapEntry, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMapEntry) -> Bool {
     if lhs.hasMapEntry_p != rhs.hasMapEntry_p {return false}
@@ -25863,12 +25785,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMaximumE
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasMaximumEdition_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasMaximumEdition_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasMaximumEdition_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMaximumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMaximumEdition) -> Bool {
     if lhs.hasMaximumEdition_p != rhs.hasMaximumEdition_p {return false}
@@ -25895,12 +25815,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageE
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasMessageEncoding_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasMessageEncoding_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasMessageEncoding_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageEncoding) -> Bool {
     if lhs.hasMessageEncoding_p != rhs.hasMessageEncoding_p {return false}
@@ -25927,12 +25845,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageS
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasMessageSetWireFormat_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasMessageSetWireFormat_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasMessageSetWireFormat_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat) -> Bool {
     if lhs.hasMessageSetWireFormat_p != rhs.hasMessageSetWireFormat_p {return false}
@@ -25959,12 +25875,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMinimumE
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasMinimumEdition_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasMinimumEdition_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasMinimumEdition_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMinimumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMinimumEdition) -> Bool {
     if lhs.hasMinimumEdition_p != rhs.hasMinimumEdition_p {return false}
@@ -25991,12 +25905,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasName: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasName_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasName_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasName_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasName) -> Bool {
     if lhs.hasName_p != rhs.hasName_p {return false}
@@ -26023,12 +25935,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNamePart
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasNamePart_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasNamePart_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasNamePart_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNamePart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNamePart) -> Bool {
     if lhs.hasNamePart_p != rhs.hasNamePart_p {return false}
@@ -26055,12 +25965,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNegative
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasNegativeIntValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasNegativeIntValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasNegativeIntValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNegativeIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNegativeIntValue) -> Bool {
     if lhs.hasNegativeIntValue_p != rhs.hasNegativeIntValue_p {return false}
@@ -26087,12 +25995,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNoStanda
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasNoStandardDescriptorAccessor_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasNoStandardDescriptorAccessor_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasNoStandardDescriptorAccessor_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor) -> Bool {
     if lhs.hasNoStandardDescriptorAccessor_p != rhs.hasNoStandardDescriptorAccessor_p {return false}
@@ -26119,12 +26025,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNumber:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasNumber_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasNumber_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasNumber_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNumber) -> Bool {
     if lhs.hasNumber_p != rhs.hasNumber_p {return false}
@@ -26151,12 +26055,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasObjcClas
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasObjcClassPrefix_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasObjcClassPrefix_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasObjcClassPrefix_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasObjcClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasObjcClassPrefix) -> Bool {
     if lhs.hasObjcClassPrefix_p != rhs.hasObjcClassPrefix_p {return false}
@@ -26183,12 +26085,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOneofInd
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasOneofIndex_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasOneofIndex_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasOneofIndex_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOneofIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOneofIndex) -> Bool {
     if lhs.hasOneofIndex_p != rhs.hasOneofIndex_p {return false}
@@ -26215,12 +26115,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptimize
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasOptimizeFor_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasOptimizeFor_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasOptimizeFor_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptimizeFor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptimizeFor) -> Bool {
     if lhs.hasOptimizeFor_p != rhs.hasOptimizeFor_p {return false}
@@ -26247,12 +26145,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptions:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasOptions_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasOptions_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasOptions_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptions) -> Bool {
     if lhs.hasOptions_p != rhs.hasOptions_p {return false}
@@ -26279,12 +26175,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOutputTy
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasOutputType_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasOutputType_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasOutputType_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOutputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOutputType) -> Bool {
     if lhs.hasOutputType_p != rhs.hasOutputType_p {return false}
@@ -26311,12 +26205,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPackage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasPackage_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasPackage_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasPackage_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPackage) -> Bool {
     if lhs.hasPackage_p != rhs.hasPackage_p {return false}
@@ -26343,12 +26235,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPacked:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasPacked_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasPacked_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasPacked_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPacked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPacked) -> Bool {
     if lhs.hasPacked_p != rhs.hasPacked_p {return false}
@@ -26375,12 +26265,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpClass
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasPhpClassPrefix_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasPhpClassPrefix_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasPhpClassPrefix_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpClassPrefix) -> Bool {
     if lhs.hasPhpClassPrefix_p != rhs.hasPhpClassPrefix_p {return false}
@@ -26407,12 +26295,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpGener
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasPhpGenericServices_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasPhpGenericServices_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasPhpGenericServices_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpGenericServices) -> Bool {
     if lhs.hasPhpGenericServices_p != rhs.hasPhpGenericServices_p {return false}
@@ -26439,12 +26325,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpMetad
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasPhpMetadataNamespace_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasPhpMetadataNamespace_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasPhpMetadataNamespace_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace) -> Bool {
     if lhs.hasPhpMetadataNamespace_p != rhs.hasPhpMetadataNamespace_p {return false}
@@ -26471,12 +26355,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpNames
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasPhpNamespace_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasPhpNamespace_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasPhpNamespace_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpNamespace) -> Bool {
     if lhs.hasPhpNamespace_p != rhs.hasPhpNamespace_p {return false}
@@ -26503,12 +26385,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPositive
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasPositiveIntValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasPositiveIntValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasPositiveIntValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPositiveIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPositiveIntValue) -> Bool {
     if lhs.hasPositiveIntValue_p != rhs.hasPositiveIntValue_p {return false}
@@ -26535,12 +26415,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasProto3Op
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasProto3Optional_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasProto3Optional_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasProto3Optional_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasProto3Optional, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasProto3Optional) -> Bool {
     if lhs.hasProto3Optional_p != rhs.hasProto3Optional_p {return false}
@@ -26567,12 +26445,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPyGeneri
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasPyGenericServices_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasPyGenericServices_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasPyGenericServices_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPyGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPyGenericServices) -> Bool {
     if lhs.hasPyGenericServices_p != rhs.hasPyGenericServices_p {return false}
@@ -26599,12 +26475,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeated
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasRepeated_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasRepeated_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasRepeated_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeated) -> Bool {
     if lhs.hasRepeated_p != rhs.hasRepeated_p {return false}
@@ -26631,12 +26505,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeated
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasRepeatedFieldEncoding_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasRepeatedFieldEncoding_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasRepeatedFieldEncoding_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeatedFieldEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeatedFieldEncoding) -> Bool {
     if lhs.hasRepeatedFieldEncoding_p != rhs.hasRepeatedFieldEncoding_p {return false}
@@ -26663,12 +26535,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasReserved
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasReserved_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasReserved_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasReserved_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasReserved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasReserved) -> Bool {
     if lhs.hasReserved_p != rhs.hasReserved_p {return false}
@@ -26695,12 +26565,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRetentio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasRetention_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasRetention_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasRetention_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRetention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRetention) -> Bool {
     if lhs.hasRetention_p != rhs.hasRetention_p {return false}
@@ -26727,12 +26595,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRubyPack
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasRubyPackage_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasRubyPackage_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasRubyPackage_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRubyPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRubyPackage) -> Bool {
     if lhs.hasRubyPackage_p != rhs.hasRubyPackage_p {return false}
@@ -26759,12 +26625,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSemantic
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasSemantic_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasSemantic_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasSemantic_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSemantic, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSemantic) -> Bool {
     if lhs.hasSemantic_p != rhs.hasSemantic_p {return false}
@@ -26791,12 +26655,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasServerSt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasServerStreaming_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasServerStreaming_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasServerStreaming_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasServerStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasServerStreaming) -> Bool {
     if lhs.hasServerStreaming_p != rhs.hasServerStreaming_p {return false}
@@ -26823,12 +26685,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceCo
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasSourceCodeInfo_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasSourceCodeInfo_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasSourceCodeInfo_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceCodeInfo) -> Bool {
     if lhs.hasSourceCodeInfo_p != rhs.hasSourceCodeInfo_p {return false}
@@ -26855,12 +26715,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceCo
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasSourceContext_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasSourceContext_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasSourceContext_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceContext) -> Bool {
     if lhs.hasSourceContext_p != rhs.hasSourceContext_p {return false}
@@ -26887,12 +26745,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceFi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasSourceFile_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasSourceFile_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasSourceFile_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceFile, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceFile) -> Bool {
     if lhs.hasSourceFile_p != rhs.hasSourceFile_p {return false}
@@ -26919,12 +26775,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStart: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasStart_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasStart_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasStart_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStart) -> Bool {
     if lhs.hasStart_p != rhs.hasStart_p {return false}
@@ -26951,12 +26805,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStringVa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasStringValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasStringValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasStringValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStringValue) -> Bool {
     if lhs.hasStringValue_p != rhs.hasStringValue_p {return false}
@@ -26983,12 +26835,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSwiftPre
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasSwiftPrefix_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasSwiftPrefix_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasSwiftPrefix_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSwiftPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSwiftPrefix) -> Bool {
     if lhs.hasSwiftPrefix_p != rhs.hasSwiftPrefix_p {return false}
@@ -27015,12 +26865,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSyntax:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasSyntax_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasSyntax_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasSyntax_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSyntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSyntax) -> Bool {
     if lhs.hasSyntax_p != rhs.hasSyntax_p {return false}
@@ -27047,12 +26895,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTrailing
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasTrailingComments_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasTrailingComments_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasTrailingComments_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTrailingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTrailingComments) -> Bool {
     if lhs.hasTrailingComments_p != rhs.hasTrailingComments_p {return false}
@@ -27079,12 +26925,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasType: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasType_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasType_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasType_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasType) -> Bool {
     if lhs.hasType_p != rhs.hasType_p {return false}
@@ -27111,12 +26955,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTypeName
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasTypeName_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasTypeName_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasTypeName_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTypeName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTypeName) -> Bool {
     if lhs.hasTypeName_p != rhs.hasTypeName_p {return false}
@@ -27143,12 +26985,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUnverifi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasUnverifiedLazy_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasUnverifiedLazy_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasUnverifiedLazy_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUnverifiedLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUnverifiedLazy) -> Bool {
     if lhs.hasUnverifiedLazy_p != rhs.hasUnverifiedLazy_p {return false}
@@ -27175,12 +27015,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUtf8Vali
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasUtf8Validation_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasUtf8Validation_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasUtf8Validation_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUtf8Validation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUtf8Validation) -> Bool {
     if lhs.hasUtf8Validation_p != rhs.hasUtf8Validation_p {return false}
@@ -27207,12 +27045,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasValue: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasValue_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasValue_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasValue) -> Bool {
     if lhs.hasValue_p != rhs.hasValue_p {return false}
@@ -27239,12 +27075,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVerifica
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasVerification_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasVerification_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasVerification_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVerification, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVerification) -> Bool {
     if lhs.hasVerification_p != rhs.hasVerification_p {return false}
@@ -27271,12 +27105,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasWeak: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hasWeak_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasWeak_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hasWeak_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasWeak, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasWeak) -> Bool {
     if lhs.hasWeak_p != rhs.hasWeak_p {return false}
@@ -27303,12 +27135,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hour: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.hour != 0 {
-      try visitor.visitSingularInt32Field(value: self.hour, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hour }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hour, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hour) -> Bool {
     if lhs.hour != rhs.hour {return false}
@@ -27335,12 +27165,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.i: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.i != 0 {
-      try visitor.visitSingularInt32Field(value: self.i, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.i }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.i, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.i) -> Bool {
     if lhs.i != rhs.i {return false}
@@ -27367,12 +27195,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.idempotency
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.idempotencyLevel != 0 {
-      try visitor.visitSingularInt32Field(value: self.idempotencyLevel, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.idempotencyLevel }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.idempotencyLevel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.idempotencyLevel) -> Bool {
     if lhs.idempotencyLevel != rhs.idempotencyLevel {return false}
@@ -27399,12 +27225,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.identifierV
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.identifierValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.identifierValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.identifierValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.identifierValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.identifierValue) -> Bool {
     if lhs.identifierValue != rhs.identifierValue {return false}
@@ -27431,12 +27255,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ifMessage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`if` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`if`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`if` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ifMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ifMessage) -> Bool {
     if lhs.`if` != rhs.`if` {return false}
@@ -27463,12 +27285,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnkno
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.ignoreUnknownFields != 0 {
-      try visitor.visitSingularInt32Field(value: self.ignoreUnknownFields, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.ignoreUnknownFields }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownFields) -> Bool {
     if lhs.ignoreUnknownFields != rhs.ignoreUnknownFields {return false}
@@ -27495,12 +27315,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.index: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.index != 0 {
-      try visitor.visitSingularInt32Field(value: self.index, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.index }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.index, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.index) -> Bool {
     if lhs.index != rhs.index {return false}
@@ -27527,12 +27345,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.initMessage
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.init_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.init_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.init_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.initMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.initMessage) -> Bool {
     if lhs.init_p != rhs.init_p {return false}
@@ -27559,12 +27375,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inoutMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`inout` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`inout`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`inout` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inoutMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inoutMessage) -> Bool {
     if lhs.`inout` != rhs.`inout` {return false}
@@ -27591,12 +27405,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inputType:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.inputType != 0 {
-      try visitor.visitSingularInt32Field(value: self.inputType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.inputType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inputType) -> Bool {
     if lhs.inputType != rhs.inputType {return false}
@@ -27623,12 +27435,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.insert: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.insert != 0 {
-      try visitor.visitSingularInt32Field(value: self.insert, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.insert }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.insert, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.insert) -> Bool {
     if lhs.insert != rhs.insert {return false}
@@ -27655,12 +27465,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntMessage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.int != 0 {
-      try visitor.visitSingularInt32Field(value: self.int, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.int }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntMessage) -> Bool {
     if lhs.int != rhs.int {return false}
@@ -27687,12 +27495,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.int32 != 0 {
-      try visitor.visitSingularInt32Field(value: self.int32, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.int32 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Message) -> Bool {
     if lhs.int32 != rhs.int32 {return false}
@@ -27719,12 +27525,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Value:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.int32Value != 0 {
-      try visitor.visitSingularInt32Field(value: self.int32Value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.int32Value }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Value) -> Bool {
     if lhs.int32Value != rhs.int32Value {return false}
@@ -27751,12 +27555,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.int64 != 0 {
-      try visitor.visitSingularInt32Field(value: self.int64, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.int64 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Message) -> Bool {
     if lhs.int64 != rhs.int64 {return false}
@@ -27783,12 +27585,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Value:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.int64Value != 0 {
-      try visitor.visitSingularInt32Field(value: self.int64Value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.int64Value }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Value) -> Bool {
     if lhs.int64Value != rhs.int64Value {return false}
@@ -27815,12 +27615,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int8: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.int8 != 0 {
-      try visitor.visitSingularInt32Field(value: self.int8, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.int8 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int8) -> Bool {
     if lhs.int8 != rhs.int8 {return false}
@@ -27847,12 +27645,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.integerLite
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.integerLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.integerLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.integerLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.integerLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.integerLiteral) -> Bool {
     if lhs.integerLiteral != rhs.integerLiteral {return false}
@@ -27879,12 +27675,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntegerLite
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.integerLiteralType != 0 {
-      try visitor.visitSingularInt32Field(value: self.integerLiteralType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.integerLiteralType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntegerLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntegerLiteralType) -> Bool {
     if lhs.integerLiteralType != rhs.integerLiteralType {return false}
@@ -27911,12 +27705,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intern: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.intern != 0 {
-      try visitor.visitSingularInt32Field(value: self.intern, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.intern }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intern, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intern) -> Bool {
     if lhs.intern != rhs.intern {return false}
@@ -27943,12 +27735,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Internal: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`internal` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`internal`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`internal` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Internal, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Internal) -> Bool {
     if lhs.`internal` != rhs.`internal` {return false}
@@ -27975,12 +27765,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.InternalSta
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.internalState != 0 {
-      try visitor.visitSingularInt32Field(value: self.internalState, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.internalState }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.InternalState, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.InternalState) -> Bool {
     if lhs.internalState != rhs.internalState {return false}
@@ -28007,12 +27795,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.into: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.into != 0 {
-      try visitor.visitSingularInt32Field(value: self.into, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.into }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.into, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.into) -> Bool {
     if lhs.into != rhs.into {return false}
@@ -28039,12 +27825,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ints: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.ints != 0 {
-      try visitor.visitSingularInt32Field(value: self.ints, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.ints }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ints, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ints) -> Bool {
     if lhs.ints != rhs.ints {return false}
@@ -28071,12 +27855,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isA: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.isA != 0 {
-      try visitor.visitSingularInt32Field(value: self.isA, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isA }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isA, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isA) -> Bool {
     if lhs.isA != rhs.isA {return false}
@@ -28103,12 +27885,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqual: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.isEqual != 0 {
-      try visitor.visitSingularInt32Field(value: self.isEqual, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isEqual }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqual, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqual) -> Bool {
     if lhs.isEqual != rhs.isEqual {return false}
@@ -28135,12 +27915,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqualTo:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.isEqualTo != 0 {
-      try visitor.visitSingularInt32Field(value: self.isEqualTo, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isEqualTo }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqualTo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqualTo) -> Bool {
     if lhs.isEqualTo != rhs.isEqualTo {return false}
@@ -28167,12 +27945,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isExtension
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.isExtension != 0 {
-      try visitor.visitSingularInt32Field(value: self.isExtension, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isExtension }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isExtension) -> Bool {
     if lhs.isExtension != rhs.isExtension {return false}
@@ -28199,12 +27975,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isInitializ
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.isInitialized_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.isInitialized_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isInitialized_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isInitializedMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isInitializedMessage) -> Bool {
     if lhs.isInitialized_p != rhs.isInitialized_p {return false}
@@ -28231,12 +28005,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isNegative:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.isNegative != 0 {
-      try visitor.visitSingularInt32Field(value: self.isNegative, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isNegative }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isNegative, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isNegative) -> Bool {
     if lhs.isNegative != rhs.isNegative {return false}
@@ -28245,6 +28017,36 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isNegative:
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isUnset: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isUnset"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "isUnset"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.isUnset) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isUnset }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isUnset, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isUnset) -> Bool {
+    if lhs.isUnset != rhs.isUnset {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.itemTagsEncodedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".itemTagsEncodedSize"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -28263,12 +28065,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.itemTagsEnc
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.itemTagsEncodedSize != 0 {
-      try visitor.visitSingularInt32Field(value: self.itemTagsEncodedSize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.itemTagsEncodedSize }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.itemTagsEncodedSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.itemTagsEncodedSize) -> Bool {
     if lhs.itemTagsEncodedSize != rhs.itemTagsEncodedSize {return false}
@@ -28295,12 +28095,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.iterator: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.iterator != 0 {
-      try visitor.visitSingularInt32Field(value: self.iterator, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.iterator }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.iterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.iterator) -> Bool {
     if lhs.iterator != rhs.iterator {return false}
@@ -28327,12 +28125,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenerat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.javaGenerateEqualsAndHash != 0 {
-      try visitor.visitSingularInt32Field(value: self.javaGenerateEqualsAndHash, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.javaGenerateEqualsAndHash }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash) -> Bool {
     if lhs.javaGenerateEqualsAndHash != rhs.javaGenerateEqualsAndHash {return false}
@@ -28359,12 +28155,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGeneric
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.javaGenericServices != 0 {
-      try visitor.visitSingularInt32Field(value: self.javaGenericServices, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.javaGenericServices }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenericServices) -> Bool {
     if lhs.javaGenericServices != rhs.javaGenericServices {return false}
@@ -28391,12 +28185,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaMultipl
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.javaMultipleFiles != 0 {
-      try visitor.visitSingularInt32Field(value: self.javaMultipleFiles, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.javaMultipleFiles }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaMultipleFiles, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaMultipleFiles) -> Bool {
     if lhs.javaMultipleFiles != rhs.javaMultipleFiles {return false}
@@ -28423,12 +28215,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaOuterCl
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.javaOuterClassname != 0 {
-      try visitor.visitSingularInt32Field(value: self.javaOuterClassname, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.javaOuterClassname }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaOuterClassname, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaOuterClassname) -> Bool {
     if lhs.javaOuterClassname != rhs.javaOuterClassname {return false}
@@ -28455,12 +28245,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaPackage
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.javaPackage != 0 {
-      try visitor.visitSingularInt32Field(value: self.javaPackage, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.javaPackage }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaPackage) -> Bool {
     if lhs.javaPackage != rhs.javaPackage {return false}
@@ -28487,12 +28275,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaStringC
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.javaStringCheckUtf8 != 0 {
-      try visitor.visitSingularInt32Field(value: self.javaStringCheckUtf8, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.javaStringCheckUtf8 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaStringCheckUtf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaStringCheckUtf8) -> Bool {
     if lhs.javaStringCheckUtf8 != rhs.javaStringCheckUtf8 {return false}
@@ -28519,12 +28305,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoder
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsondecoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsondecoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsondecoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoder) -> Bool {
     if lhs.jsondecoder != rhs.jsondecoder {return false}
@@ -28551,12 +28335,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodin
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsondecodingError != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsondecodingError, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsondecodingError }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingError) -> Bool {
     if lhs.jsondecodingError != rhs.jsondecodingError {return false}
@@ -28583,12 +28365,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodin
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsondecodingOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsondecodingOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsondecodingOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingOptions) -> Bool {
     if lhs.jsondecodingOptions != rhs.jsondecodingOptions {return false}
@@ -28615,12 +28395,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonEncoder
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonEncoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonEncoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonEncoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonEncoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonEncoder) -> Bool {
     if lhs.jsonEncoder != rhs.jsonEncoder {return false}
@@ -28647,12 +28425,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodin
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonencodingError != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonencodingError, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonencodingError }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingError) -> Bool {
     if lhs.jsonencodingError != rhs.jsonencodingError {return false}
@@ -28679,12 +28455,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodin
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonencodingOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonencodingOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonencodingOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingOptions) -> Bool {
     if lhs.jsonencodingOptions != rhs.jsonencodingOptions {return false}
@@ -28711,12 +28485,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodin
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonencodingVisitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonencodingVisitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonencodingVisitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingVisitor) -> Bool {
     if lhs.jsonencodingVisitor != rhs.jsonencodingVisitor {return false}
@@ -28743,12 +28515,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonFormat:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonFormat != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonFormat, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonFormat }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonFormat) -> Bool {
     if lhs.jsonFormat != rhs.jsonFormat {return false}
@@ -28775,12 +28545,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONMapEnco
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonmapEncodingVisitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonmapEncodingVisitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonmapEncodingVisitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor) -> Bool {
     if lhs.jsonmapEncodingVisitor != rhs.jsonmapEncodingVisitor {return false}
@@ -28807,12 +28575,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonName: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonName != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonName }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonName) -> Bool {
     if lhs.jsonName != rhs.jsonName {return false}
@@ -28839,12 +28605,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPath: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonPath != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonPath, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonPath }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPath, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPath) -> Bool {
     if lhs.jsonPath != rhs.jsonPath {return false}
@@ -28871,12 +28635,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPaths:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonPaths != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonPaths, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonPaths }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPaths, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPaths) -> Bool {
     if lhs.jsonPaths != rhs.jsonPaths {return false}
@@ -28903,12 +28665,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONScanner
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonscanner != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonscanner, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonscanner }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONScanner, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONScanner) -> Bool {
     if lhs.jsonscanner != rhs.jsonscanner {return false}
@@ -28935,12 +28695,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonString:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonString != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonString, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonString }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonString) -> Bool {
     if lhs.jsonString != rhs.jsonString {return false}
@@ -28967,12 +28725,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonText: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonText != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonText, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonText }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonText, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonText) -> Bool {
     if lhs.jsonText != rhs.jsonText {return false}
@@ -28999,12 +28755,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Byt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonUtf8Bytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonUtf8Bytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonUtf8Bytes }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Bytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Bytes) -> Bool {
     if lhs.jsonUtf8Bytes != rhs.jsonUtf8Bytes {return false}
@@ -29031,12 +28785,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Dat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jsonUtf8Data != 0 {
-      try visitor.visitSingularInt32Field(value: self.jsonUtf8Data, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonUtf8Data }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Data, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Data) -> Bool {
     if lhs.jsonUtf8Data != rhs.jsonUtf8Data {return false}
@@ -29063,12 +28815,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jstype: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.jstype != 0 {
-      try visitor.visitSingularInt32Field(value: self.jstype, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jstype }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jstype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jstype) -> Bool {
     if lhs.jstype != rhs.jstype {return false}
@@ -29095,12 +28845,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.k: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.k != 0 {
-      try visitor.visitSingularInt32Field(value: self.k, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.k }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.k, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.k) -> Bool {
     if lhs.k != rhs.k {return false}
@@ -29127,12 +28875,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kChunkSize:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.kChunkSize != 0 {
-      try visitor.visitSingularInt32Field(value: self.kChunkSize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.kChunkSize }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kChunkSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kChunkSize) -> Bool {
     if lhs.kChunkSize != rhs.kChunkSize {return false}
@@ -29159,12 +28905,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Key: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.key != 0 {
-      try visitor.visitSingularInt32Field(value: self.key, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.key }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Key, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Key) -> Bool {
     if lhs.key != rhs.key {return false}
@@ -29191,12 +28935,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyField: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.keyField != 0 {
-      try visitor.visitSingularInt32Field(value: self.keyField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.keyField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyField) -> Bool {
     if lhs.keyField != rhs.keyField {return false}
@@ -29223,12 +28965,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyFieldOpt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.keyFieldOpt != 0 {
-      try visitor.visitSingularInt32Field(value: self.keyFieldOpt, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.keyFieldOpt }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyFieldOpt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyFieldOpt) -> Bool {
     if lhs.keyFieldOpt != rhs.keyFieldOpt {return false}
@@ -29255,12 +28995,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.KeyType: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.keyType != 0 {
-      try visitor.visitSingularInt32Field(value: self.keyType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.keyType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.KeyType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.KeyType) -> Bool {
     if lhs.keyType != rhs.keyType {return false}
@@ -29287,12 +29025,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kind: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.kind != 0 {
-      try visitor.visitSingularInt32Field(value: self.kind, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.kind }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kind, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kind) -> Bool {
     if lhs.kind != rhs.kind {return false}
@@ -29319,12 +29055,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.l: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.l != 0 {
-      try visitor.visitSingularInt32Field(value: self.l, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.l }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.l, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.l) -> Bool {
     if lhs.l != rhs.l {return false}
@@ -29351,12 +29085,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.label: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.label != 0 {
-      try visitor.visitSingularInt32Field(value: self.label, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.label }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.label, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.label) -> Bool {
     if lhs.label != rhs.label {return false}
@@ -29383,12 +29115,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lazy: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.lazy != 0 {
-      try visitor.visitSingularInt32Field(value: self.lazy, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.lazy }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lazy) -> Bool {
     if lhs.lazy != rhs.lazy {return false}
@@ -29415,12 +29145,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingComm
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.leadingComments != 0 {
-      try visitor.visitSingularInt32Field(value: self.leadingComments, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.leadingComments }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingComments) -> Bool {
     if lhs.leadingComments != rhs.leadingComments {return false}
@@ -29447,12 +29175,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingDeta
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.leadingDetachedComments != 0 {
-      try visitor.visitSingularInt32Field(value: self.leadingDetachedComments, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.leadingDetachedComments }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingDetachedComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingDetachedComments) -> Bool {
     if lhs.leadingDetachedComments != rhs.leadingDetachedComments {return false}
@@ -29479,12 +29205,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.length: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.length != 0 {
-      try visitor.visitSingularInt32Field(value: self.length, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.length }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.length, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.length) -> Bool {
     if lhs.length != rhs.length {return false}
@@ -29511,12 +29235,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lessThan: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.lessThan != 0 {
-      try visitor.visitSingularInt32Field(value: self.lessThan, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.lessThan }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lessThan, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lessThan) -> Bool {
     if lhs.lessThan != rhs.lessThan {return false}
@@ -29543,12 +29265,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.letMessage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`let` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`let`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`let` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.letMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.letMessage) -> Bool {
     if lhs.`let` != rhs.`let` {return false}
@@ -29575,12 +29295,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lhs: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.lhs != 0 {
-      try visitor.visitSingularInt32Field(value: self.lhs, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.lhs }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lhs, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lhs) -> Bool {
     if lhs.lhs != rhs.lhs {return false}
@@ -29607,12 +29325,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.list: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.list != 0 {
-      try visitor.visitSingularInt32Field(value: self.list, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.list }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.list, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.list) -> Bool {
     if lhs.list != rhs.list {return false}
@@ -29639,12 +29355,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listOfMessa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.listOfMessages != 0 {
-      try visitor.visitSingularInt32Field(value: self.listOfMessages, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.listOfMessages }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listOfMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listOfMessages) -> Bool {
     if lhs.listOfMessages != rhs.listOfMessages {return false}
@@ -29671,12 +29385,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listValue:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.listValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.listValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.listValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listValue) -> Bool {
     if lhs.listValue != rhs.listValue {return false}
@@ -29703,12 +29415,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndia
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.littleEndian != 0 {
-      try visitor.visitSingularInt32Field(value: self.littleEndian, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.littleEndian }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndian, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndian) -> Bool {
     if lhs.littleEndian != rhs.littleEndian {return false}
@@ -29735,12 +29445,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndia
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.littleEndianBytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.littleEndianBytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.littleEndianBytes }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndianBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndianBytes) -> Bool {
     if lhs.littleEndianBytes != rhs.littleEndianBytes {return false}
@@ -29767,12 +29475,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.load: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.load != 0 {
-      try visitor.visitSingularInt32Field(value: self.load, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.load }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.load, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.load) -> Bool {
     if lhs.load != rhs.load {return false}
@@ -29799,12 +29505,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.localHasher
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.localHasher != 0 {
-      try visitor.visitSingularInt32Field(value: self.localHasher, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.localHasher }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.localHasher, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.localHasher) -> Bool {
     if lhs.localHasher != rhs.localHasher {return false}
@@ -29831,12 +29535,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.location: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.location != 0 {
-      try visitor.visitSingularInt32Field(value: self.location, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.location }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.location, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.location) -> Bool {
     if lhs.location != rhs.location {return false}
@@ -29863,12 +29565,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.M: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.m != 0 {
-      try visitor.visitSingularInt32Field(value: self.m, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.m }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.M, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.M) -> Bool {
     if lhs.m != rhs.m {return false}
@@ -29895,12 +29595,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.major: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.major != 0 {
-      try visitor.visitSingularInt32Field(value: self.major, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.major }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.major, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.major) -> Bool {
     if lhs.major != rhs.major {return false}
@@ -29927,12 +29625,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeAsyncIt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.makeAsyncIterator != 0 {
-      try visitor.visitSingularInt32Field(value: self.makeAsyncIterator, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.makeAsyncIterator }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeAsyncIterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeAsyncIterator) -> Bool {
     if lhs.makeAsyncIterator != rhs.makeAsyncIterator {return false}
@@ -29959,12 +29655,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeIterato
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.makeIterator != 0 {
-      try visitor.visitSingularInt32Field(value: self.makeIterator, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.makeIterator }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeIterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeIterator) -> Bool {
     if lhs.makeIterator != rhs.makeIterator {return false}
@@ -29973,6 +29667,36 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeIterato
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.map: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".map"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "map"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.map) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.map }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.map, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.map) -> Bool {
+    if lhs.map != rhs.map {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mapEntry"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -29991,12 +29715,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapEntry: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.mapEntry != 0 {
-      try visitor.visitSingularInt32Field(value: self.mapEntry, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mapEntry }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapEntry, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapEntry) -> Bool {
     if lhs.mapEntry != rhs.mapEntry {return false}
@@ -30023,12 +29745,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapKeyType:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.mapKeyType != 0 {
-      try visitor.visitSingularInt32Field(value: self.mapKeyType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mapKeyType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapKeyType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapKeyType) -> Bool {
     if lhs.mapKeyType != rhs.mapKeyType {return false}
@@ -30055,12 +29775,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapToMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.mapToMessages != 0 {
-      try visitor.visitSingularInt32Field(value: self.mapToMessages, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mapToMessages }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapToMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapToMessages) -> Bool {
     if lhs.mapToMessages != rhs.mapToMessages {return false}
@@ -30087,12 +29805,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapValueTyp
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.mapValueType != 0 {
-      try visitor.visitSingularInt32Field(value: self.mapValueType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mapValueType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapValueType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapValueType) -> Bool {
     if lhs.mapValueType != rhs.mapValueType {return false}
@@ -30119,12 +29835,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapVisitor:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.mapVisitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.mapVisitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mapVisitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapVisitor) -> Bool {
     if lhs.mapVisitor != rhs.mapVisitor {return false}
@@ -30151,12 +29865,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.maximumEdit
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.maximumEdition != 0 {
-      try visitor.visitSingularInt32Field(value: self.maximumEdition, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.maximumEdition }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.maximumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.maximumEdition) -> Bool {
     if lhs.maximumEdition != rhs.maximumEdition {return false}
@@ -30183,12 +29895,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mdayStart:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.mdayStart != 0 {
-      try visitor.visitSingularInt32Field(value: self.mdayStart, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mdayStart }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mdayStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mdayStart) -> Bool {
     if lhs.mdayStart != rhs.mdayStart {return false}
@@ -30215,12 +29925,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.merge: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.merge != 0 {
-      try visitor.visitSingularInt32Field(value: self.merge, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.merge }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.merge, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.merge) -> Bool {
     if lhs.merge != rhs.merge {return false}
@@ -30247,12 +29955,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.message: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.message != 0 {
-      try visitor.visitSingularInt32Field(value: self.message, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.message }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.message) -> Bool {
     if lhs.message != rhs.message {return false}
@@ -30279,12 +29985,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageDept
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.messageDepthLimit != 0 {
-      try visitor.visitSingularInt32Field(value: self.messageDepthLimit, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.messageDepthLimit }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageDepthLimit, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageDepthLimit) -> Bool {
     if lhs.messageDepthLimit != rhs.messageDepthLimit {return false}
@@ -30311,12 +30015,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageEnco
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.messageEncoding != 0 {
-      try visitor.visitSingularInt32Field(value: self.messageEncoding, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.messageEncoding }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageEncoding) -> Bool {
     if lhs.messageEncoding != rhs.messageEncoding {return false}
@@ -30343,12 +30045,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageExte
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.messageExtension != 0 {
-      try visitor.visitSingularInt32Field(value: self.messageExtension, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.messageExtension }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageExtension) -> Bool {
     if lhs.messageExtension != rhs.messageExtension {return false}
@@ -30375,12 +30075,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageImpl
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.messageImplementationBase != 0 {
-      try visitor.visitSingularInt32Field(value: self.messageImplementationBase, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.messageImplementationBase }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageImplementationBase, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageImplementationBase) -> Bool {
     if lhs.messageImplementationBase != rhs.messageImplementationBase {return false}
@@ -30407,12 +30105,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageOpti
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.messageOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.messageOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.messageOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageOptions) -> Bool {
     if lhs.messageOptions != rhs.messageOptions {return false}
@@ -30439,12 +30135,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageSet:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.messageSet != 0 {
-      try visitor.visitSingularInt32Field(value: self.messageSet, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.messageSet }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageSet) -> Bool {
     if lhs.messageSet != rhs.messageSet {return false}
@@ -30471,12 +30165,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSetW
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.messageSetWireFormat != 0 {
-      try visitor.visitSingularInt32Field(value: self.messageSetWireFormat, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.messageSetWireFormat }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSetWireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSetWireFormat) -> Bool {
     if lhs.messageSetWireFormat != rhs.messageSetWireFormat {return false}
@@ -30503,12 +30195,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSize
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.messageSize != 0 {
-      try visitor.visitSingularInt32Field(value: self.messageSize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.messageSize }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSize) -> Bool {
     if lhs.messageSize != rhs.messageSize {return false}
@@ -30535,12 +30225,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageType
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.messageType != 0 {
-      try visitor.visitSingularInt32Field(value: self.messageType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.messageType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageType) -> Bool {
     if lhs.messageType != rhs.messageType {return false}
@@ -30567,12 +30255,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Method: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.method != 0 {
-      try visitor.visitSingularInt32Field(value: self.method, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.method }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Method, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Method) -> Bool {
     if lhs.method != rhs.method {return false}
@@ -30599,12 +30285,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MethodDescr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.methodDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.methodDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.methodDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MethodDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MethodDescriptorProto) -> Bool {
     if lhs.methodDescriptorProto != rhs.methodDescriptorProto {return false}
@@ -30631,12 +30315,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MethodOptio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.methodOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.methodOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.methodOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MethodOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MethodOptions) -> Bool {
     if lhs.methodOptions != rhs.methodOptions {return false}
@@ -30663,12 +30345,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.methods: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.methods != 0 {
-      try visitor.visitSingularInt32Field(value: self.methods, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.methods }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.methods, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.methods) -> Bool {
     if lhs.methods != rhs.methods {return false}
@@ -30695,12 +30375,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.min: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.min != 0 {
-      try visitor.visitSingularInt32Field(value: self.min, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.min }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.min, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.min) -> Bool {
     if lhs.min != rhs.min {return false}
@@ -30727,12 +30405,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minimumEdit
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.minimumEdition != 0 {
-      try visitor.visitSingularInt32Field(value: self.minimumEdition, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.minimumEdition }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minimumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minimumEdition) -> Bool {
     if lhs.minimumEdition != rhs.minimumEdition {return false}
@@ -30759,12 +30435,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minor: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.minor != 0 {
-      try visitor.visitSingularInt32Field(value: self.minor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.minor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minor) -> Bool {
     if lhs.minor != rhs.minor {return false}
@@ -30791,12 +30465,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Mixin: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.mixin != 0 {
-      try visitor.visitSingularInt32Field(value: self.mixin, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mixin }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Mixin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Mixin) -> Bool {
     if lhs.mixin != rhs.mixin {return false}
@@ -30823,12 +30495,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mixins: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.mixins != 0 {
-      try visitor.visitSingularInt32Field(value: self.mixins, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mixins }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mixins, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mixins) -> Bool {
     if lhs.mixins != rhs.mixins {return false}
@@ -30855,12 +30525,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modifier: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.modifier != 0 {
-      try visitor.visitSingularInt32Field(value: self.modifier, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.modifier }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modifier, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modifier) -> Bool {
     if lhs.modifier != rhs.modifier {return false}
@@ -30887,12 +30555,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modify: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.modify != 0 {
-      try visitor.visitSingularInt32Field(value: self.modify, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.modify }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modify, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modify) -> Bool {
     if lhs.modify != rhs.modify {return false}
@@ -30919,12 +30585,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.month: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.month != 0 {
-      try visitor.visitSingularInt32Field(value: self.month, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.month }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.month, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.month) -> Bool {
     if lhs.month != rhs.month {return false}
@@ -30951,12 +30615,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.msgExtensio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.msgExtension != 0 {
-      try visitor.visitSingularInt32Field(value: self.msgExtension, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.msgExtension }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.msgExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.msgExtension) -> Bool {
     if lhs.msgExtension != rhs.msgExtension {return false}
@@ -30983,12 +30645,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mutating: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.mutating != 0 {
-      try visitor.visitSingularInt32Field(value: self.mutating, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mutating }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mutating, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mutating) -> Bool {
     if lhs.mutating != rhs.mutating {return false}
@@ -31015,12 +30675,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.n: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.n != 0 {
-      try visitor.visitSingularInt32Field(value: self.n, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.n }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.n, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.n) -> Bool {
     if lhs.n != rhs.n {return false}
@@ -31047,12 +30705,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.name: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.name != 0 {
-      try visitor.visitSingularInt32Field(value: self.name, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.name }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.name, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.name) -> Bool {
     if lhs.name != rhs.name {return false}
@@ -31079,12 +30735,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameDescrip
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.nameDescription != 0 {
-      try visitor.visitSingularInt32Field(value: self.nameDescription, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nameDescription }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameDescription, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameDescription) -> Bool {
     if lhs.nameDescription != rhs.nameDescription {return false}
@@ -31111,12 +30765,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameMap: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.nameMap != 0 {
-      try visitor.visitSingularInt32Field(value: self.nameMap, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nameMap }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameMap) -> Bool {
     if lhs.nameMap != rhs.nameMap {return false}
@@ -31143,12 +30795,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NamePart: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.namePart != 0 {
-      try visitor.visitSingularInt32Field(value: self.namePart, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.namePart }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NamePart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NamePart) -> Bool {
     if lhs.namePart != rhs.namePart {return false}
@@ -31175,12 +30825,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.names: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.names != 0 {
-      try visitor.visitSingularInt32Field(value: self.names, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.names }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.names, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.names) -> Bool {
     if lhs.names != rhs.names {return false}
@@ -31207,12 +30855,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nanos: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.nanos != 0 {
-      try visitor.visitSingularInt32Field(value: self.nanos, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nanos }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nanos, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nanos) -> Bool {
     if lhs.nanos != rhs.nanos {return false}
@@ -31239,12 +30885,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.negativeInt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.negativeIntValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.negativeIntValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.negativeIntValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.negativeIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.negativeIntValue) -> Bool {
     if lhs.negativeIntValue != rhs.negativeIntValue {return false}
@@ -31271,12 +30915,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nestedType:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.nestedType != 0 {
-      try visitor.visitSingularInt32Field(value: self.nestedType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nestedType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nestedType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nestedType) -> Bool {
     if lhs.nestedType != rhs.nestedType {return false}
@@ -31303,12 +30945,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newL: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.newL != 0 {
-      try visitor.visitSingularInt32Field(value: self.newL, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.newL }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newL) -> Bool {
     if lhs.newL != rhs.newL {return false}
@@ -31335,12 +30975,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newList: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.newList != 0 {
-      try visitor.visitSingularInt32Field(value: self.newList, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.newList }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newList, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newList) -> Bool {
     if lhs.newList != rhs.newList {return false}
@@ -31367,12 +31005,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newValue: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.newValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.newValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.newValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newValue) -> Bool {
     if lhs.newValue != rhs.newValue {return false}
@@ -31399,12 +31035,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.next: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.next != 0 {
-      try visitor.visitSingularInt32Field(value: self.next, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.next }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.next, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.next) -> Bool {
     if lhs.next != rhs.next {return false}
@@ -31431,12 +31065,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextByte: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.nextByte != 0 {
-      try visitor.visitSingularInt32Field(value: self.nextByte, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nextByte }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextByte, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextByte) -> Bool {
     if lhs.nextByte != rhs.nextByte {return false}
@@ -31463,12 +31095,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextFieldNu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.nextFieldNumber != 0 {
-      try visitor.visitSingularInt32Field(value: self.nextFieldNumber, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nextFieldNumber }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextFieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextFieldNumber) -> Bool {
     if lhs.nextFieldNumber != rhs.nextFieldNumber {return false}
@@ -31495,12 +31125,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextVarInt:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.nextVarInt != 0 {
-      try visitor.visitSingularInt32Field(value: self.nextVarInt, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nextVarInt }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextVarInt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextVarInt) -> Bool {
     if lhs.nextVarInt != rhs.nextVarInt {return false}
@@ -31527,12 +31155,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilMessage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`nil` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`nil`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`nil` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilMessage) -> Bool {
     if lhs.`nil` != rhs.`nil` {return false}
@@ -31559,12 +31185,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilLiteral:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.nilLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.nilLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nilLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilLiteral) -> Bool {
     if lhs.nilLiteral != rhs.nilLiteral {return false}
@@ -31591,12 +31215,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noStandardD
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.noStandardDescriptorAccessor != 0 {
-      try visitor.visitSingularInt32Field(value: self.noStandardDescriptorAccessor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.noStandardDescriptorAccessor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor) -> Bool {
     if lhs.noStandardDescriptorAccessor != rhs.noStandardDescriptorAccessor {return false}
@@ -31623,12 +31245,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nullValue:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.nullValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.nullValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nullValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nullValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nullValue) -> Bool {
     if lhs.nullValue != rhs.nullValue {return false}
@@ -31655,12 +31275,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.number: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.number != 0 {
-      try visitor.visitSingularInt32Field(value: self.number, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.number }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.number, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.number) -> Bool {
     if lhs.number != rhs.number {return false}
@@ -31687,12 +31305,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.numberValue
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.numberValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.numberValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.numberValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.numberValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.numberValue) -> Bool {
     if lhs.numberValue != rhs.numberValue {return false}
@@ -31719,12 +31335,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.objcClassPr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.objcClassPrefix != 0 {
-      try visitor.visitSingularInt32Field(value: self.objcClassPrefix, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.objcClassPrefix }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.objcClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.objcClassPrefix) -> Bool {
     if lhs.objcClassPrefix != rhs.objcClassPrefix {return false}
@@ -31751,12 +31365,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.of: SwiftPr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.of != 0 {
-      try visitor.visitSingularInt32Field(value: self.of, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.of }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.of, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.of) -> Bool {
     if lhs.of != rhs.of {return false}
@@ -31765,6 +31377,36 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.of: SwiftPr
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".oneOf"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "oneOf"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.oneOf) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.oneOf }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneOf, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneOf) -> Bool {
+    if lhs.oneOf != rhs.oneOf {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofDecl: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofDecl"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -31783,12 +31425,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofDecl:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.oneofDecl != 0 {
-      try visitor.visitSingularInt32Field(value: self.oneofDecl, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.oneofDecl }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofDecl, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofDecl) -> Bool {
     if lhs.oneofDecl != rhs.oneofDecl {return false}
@@ -31815,12 +31455,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneofDescri
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.oneofDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.oneofDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.oneofDescriptorProto }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneofDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneofDescriptorProto) -> Bool {
     if lhs.oneofDescriptorProto != rhs.oneofDescriptorProto {return false}
@@ -31847,12 +31485,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofIndex:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.oneofIndex != 0 {
-      try visitor.visitSingularInt32Field(value: self.oneofIndex, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.oneofIndex }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofIndex) -> Bool {
     if lhs.oneofIndex != rhs.oneofIndex {return false}
@@ -31879,12 +31515,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneofOption
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.oneofOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.oneofOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.oneofOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneofOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneofOptions) -> Bool {
     if lhs.oneofOptions != rhs.oneofOptions {return false}
@@ -31911,12 +31545,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofs: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.oneofs != 0 {
-      try visitor.visitSingularInt32Field(value: self.oneofs, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.oneofs }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofs, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofs) -> Bool {
     if lhs.oneofs != rhs.oneofs {return false}
@@ -31943,12 +31575,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneOf_Kind:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.oneOfKind != 0 {
-      try visitor.visitSingularInt32Field(value: self.oneOfKind, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.oneOfKind }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneOf_Kind, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneOf_Kind) -> Bool {
     if lhs.oneOfKind != rhs.oneOfKind {return false}
@@ -31975,12 +31605,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optimizeFor
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.optimizeFor != 0 {
-      try visitor.visitSingularInt32Field(value: self.optimizeFor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optimizeFor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optimizeFor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optimizeFor) -> Bool {
     if lhs.optimizeFor != rhs.optimizeFor {return false}
@@ -32007,12 +31635,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptimizeMod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.optimizeMode != 0 {
-      try visitor.visitSingularInt32Field(value: self.optimizeMode, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optimizeMode }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptimizeMode, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptimizeMode) -> Bool {
     if lhs.optimizeMode != rhs.optimizeMode {return false}
@@ -32039,12 +31665,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Option: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.option != 0 {
-      try visitor.visitSingularInt32Field(value: self.option, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.option }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Option, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Option) -> Bool {
     if lhs.option != rhs.option {return false}
@@ -32071,12 +31695,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalEnu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.optionalEnumExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.optionalEnumExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalEnumExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField) -> Bool {
     if lhs.optionalEnumExtensionField != rhs.optionalEnumExtensionField {return false}
@@ -32103,12 +31725,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalExt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.optionalExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.optionalExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalExtensionField) -> Bool {
     if lhs.optionalExtensionField != rhs.optionalExtensionField {return false}
@@ -32135,12 +31755,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalGro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.optionalGroupExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.optionalGroupExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalGroupExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField) -> Bool {
     if lhs.optionalGroupExtensionField != rhs.optionalGroupExtensionField {return false}
@@ -32167,12 +31785,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalMes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.optionalMessageExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.optionalMessageExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalMessageExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField) -> Bool {
     if lhs.optionalMessageExtensionField != rhs.optionalMessageExtensionField {return false}
@@ -32199,12 +31815,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionReten
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.optionRetention != 0 {
-      try visitor.visitSingularInt32Field(value: self.optionRetention, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionRetention }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionRetention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionRetention) -> Bool {
     if lhs.optionRetention != rhs.optionRetention {return false}
@@ -32231,12 +31845,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.options: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.options != 0 {
-      try visitor.visitSingularInt32Field(value: self.options, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.options }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.options, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.options) -> Bool {
     if lhs.options != rhs.options {return false}
@@ -32263,12 +31875,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionTarge
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.optionTargetType != 0 {
-      try visitor.visitSingularInt32Field(value: self.optionTargetType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionTargetType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionTargetType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionTargetType) -> Bool {
     if lhs.optionTargetType != rhs.optionTargetType {return false}
@@ -32295,12 +31905,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.other: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.other != 0 {
-      try visitor.visitSingularInt32Field(value: self.other, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.other }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.other, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.other) -> Bool {
     if lhs.other != rhs.other {return false}
@@ -32327,12 +31935,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.others: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.others != 0 {
-      try visitor.visitSingularInt32Field(value: self.others, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.others }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.others, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.others) -> Bool {
     if lhs.others != rhs.others {return false}
@@ -32359,12 +31965,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.out: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.out != 0 {
-      try visitor.visitSingularInt32Field(value: self.out, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.out }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.out, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.out) -> Bool {
     if lhs.out != rhs.out {return false}
@@ -32391,12 +31995,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.outputType:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.outputType != 0 {
-      try visitor.visitSingularInt32Field(value: self.outputType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.outputType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.outputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.outputType) -> Bool {
     if lhs.outputType != rhs.outputType {return false}
@@ -32423,12 +32025,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.p: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.p != 0 {
-      try visitor.visitSingularInt32Field(value: self.p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.p, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.p) -> Bool {
     if lhs.p != rhs.p {return false}
@@ -32455,12 +32055,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.package: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.package != 0 {
-      try visitor.visitSingularInt32Field(value: self.package, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.package }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.package, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.package) -> Bool {
     if lhs.package != rhs.package {return false}
@@ -32487,12 +32085,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packed: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.packed != 0 {
-      try visitor.visitSingularInt32Field(value: self.packed, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packed }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packed, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packed) -> Bool {
     if lhs.packed != rhs.packed {return false}
@@ -32501,6 +32097,96 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packed: Swi
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedBool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedBool"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedBool"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedBool) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedBool }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedBool, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedBool) -> Bool {
+    if lhs.packedBool != rhs.packedBool {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedDouble"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedDouble"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedDouble) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedDouble }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedDouble, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedDouble) -> Bool {
+    if lhs.packedDouble != rhs.packedDouble {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedEnum"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedEnum"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedEnum) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedEnum }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedEnum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedEnum) -> Bool {
+    if lhs.packedEnum != rhs.packedEnum {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PackedEnumExtensionField"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -32519,12 +32205,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedEnumE
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.packedEnumExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.packedEnumExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedEnumExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedEnumExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedEnumExtensionField) -> Bool {
     if lhs.packedEnumExtensionField != rhs.packedEnumExtensionField {return false}
@@ -32551,12 +32235,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedExten
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.packedExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.packedExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedExtensionField) -> Bool {
     if lhs.packedExtensionField != rhs.packedExtensionField {return false}
@@ -32565,6 +32247,336 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedExten
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedFixed32"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedFixed32"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedFixed32) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedFixed32 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedFixed32) -> Bool {
+    if lhs.packedFixed32 != rhs.packedFixed32 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedFixed64"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedFixed64"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedFixed64) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedFixed64 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedFixed64) -> Bool {
+    if lhs.packedFixed64 != rhs.packedFixed64 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedFloat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedFloat"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedFloat"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedFloat) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedFloat }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedFloat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedFloat) -> Bool {
+    if lhs.packedFloat != rhs.packedFloat {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedInt32"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedInt32"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedInt32) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedInt32 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedInt32) -> Bool {
+    if lhs.packedInt32 != rhs.packedInt32 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedInt64"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedInt64"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedInt64) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedInt64 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedInt64) -> Bool {
+    if lhs.packedInt64 != rhs.packedInt64 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedSFixed32"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedSFixed32"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedSfixed32) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedSfixed32 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSFixed32) -> Bool {
+    if lhs.packedSfixed32 != rhs.packedSfixed32 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedSFixed64"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedSFixed64"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedSfixed64) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedSfixed64 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSFixed64) -> Bool {
+    if lhs.packedSfixed64 != rhs.packedSfixed64 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedSInt32"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedSInt32"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedSint32) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedSint32 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSInt32) -> Bool {
+    if lhs.packedSint32 != rhs.packedSint32 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedSInt64"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedSInt64"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedSint64) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedSint64 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedSInt64) -> Bool {
+    if lhs.packedSint64 != rhs.packedSint64 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedUInt32"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedUInt32"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedUint32) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedUint32 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedUInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedUInt32) -> Bool {
+    if lhs.packedUint32 != rhs.packedUint32 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packedUInt64"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "packedUInt64"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedUint64) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.packedUint64 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packedUInt64) -> Bool {
+    if lhs.packedUint64 != rhs.packedUint64 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.padding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".padding"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -32583,12 +32595,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.padding: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.padding != 0 {
-      try visitor.visitSingularInt32Field(value: self.padding, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.padding }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.padding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.padding) -> Bool {
     if lhs.padding != rhs.padding {return false}
@@ -32615,12 +32625,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parent: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.parent != 0 {
-      try visitor.visitSingularInt32Field(value: self.parent, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.parent }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parent, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parent) -> Bool {
     if lhs.parent != rhs.parent {return false}
@@ -32647,12 +32655,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parse: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.parse != 0 {
-      try visitor.visitSingularInt32Field(value: self.parse, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.parse }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parse, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parse) -> Bool {
     if lhs.parse != rhs.parse {return false}
@@ -32679,12 +32685,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.path: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.path != 0 {
-      try visitor.visitSingularInt32Field(value: self.path, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.path }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.path, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.path) -> Bool {
     if lhs.path != rhs.path {return false}
@@ -32711,12 +32715,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.paths: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.paths != 0 {
-      try visitor.visitSingularInt32Field(value: self.paths, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.paths }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.paths, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.paths) -> Bool {
     if lhs.paths != rhs.paths {return false}
@@ -32743,12 +32745,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payload: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.payload != 0 {
-      try visitor.visitSingularInt32Field(value: self.payload, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.payload }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payload, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payload) -> Bool {
     if lhs.payload != rhs.payload {return false}
@@ -32775,12 +32775,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payloadSize
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.payloadSize != 0 {
-      try visitor.visitSingularInt32Field(value: self.payloadSize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.payloadSize }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payloadSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payloadSize) -> Bool {
     if lhs.payloadSize != rhs.payloadSize {return false}
@@ -32807,12 +32805,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpClassPre
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.phpClassPrefix != 0 {
-      try visitor.visitSingularInt32Field(value: self.phpClassPrefix, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.phpClassPrefix }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpClassPrefix) -> Bool {
     if lhs.phpClassPrefix != rhs.phpClassPrefix {return false}
@@ -32839,12 +32835,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpGenericS
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.phpGenericServices != 0 {
-      try visitor.visitSingularInt32Field(value: self.phpGenericServices, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.phpGenericServices }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpGenericServices) -> Bool {
     if lhs.phpGenericServices != rhs.phpGenericServices {return false}
@@ -32871,12 +32865,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpMetadata
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.phpMetadataNamespace != 0 {
-      try visitor.visitSingularInt32Field(value: self.phpMetadataNamespace, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.phpMetadataNamespace }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpMetadataNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpMetadataNamespace) -> Bool {
     if lhs.phpMetadataNamespace != rhs.phpMetadataNamespace {return false}
@@ -32903,12 +32895,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpNamespac
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.phpNamespace != 0 {
-      try visitor.visitSingularInt32Field(value: self.phpNamespace, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.phpNamespace }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpNamespace) -> Bool {
     if lhs.phpNamespace != rhs.phpNamespace {return false}
@@ -32935,12 +32925,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pos: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.pos != 0 {
-      try visitor.visitSingularInt32Field(value: self.pos, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.pos }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pos, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pos) -> Bool {
     if lhs.pos != rhs.pos {return false}
@@ -32967,12 +32955,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.positiveInt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.positiveIntValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.positiveIntValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.positiveIntValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.positiveIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.positiveIntValue) -> Bool {
     if lhs.positiveIntValue != rhs.positiveIntValue {return false}
@@ -32999,12 +32985,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prefix: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.prefix != 0 {
-      try visitor.visitSingularInt32Field(value: self.prefix, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.prefix }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prefix) -> Bool {
     if lhs.prefix != rhs.prefix {return false}
@@ -33031,12 +33015,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preservePro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.preserveProtoFieldNames != 0 {
-      try visitor.visitSingularInt32Field(value: self.preserveProtoFieldNames, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.preserveProtoFieldNames }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preserveProtoFieldNames, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preserveProtoFieldNames) -> Bool {
     if lhs.preserveProtoFieldNames != rhs.preserveProtoFieldNames {return false}
@@ -33063,12 +33045,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preTraverse
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.preTraverse != 0 {
-      try visitor.visitSingularInt32Field(value: self.preTraverse, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.preTraverse }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preTraverse, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preTraverse) -> Bool {
     if lhs.preTraverse != rhs.preTraverse {return false}
@@ -33095,12 +33075,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.printUnknow
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.printUnknownFields != 0 {
-      try visitor.visitSingularInt32Field(value: self.printUnknownFields, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.printUnknownFields }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.printUnknownFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.printUnknownFields) -> Bool {
     if lhs.printUnknownFields != rhs.printUnknownFields {return false}
@@ -33127,12 +33105,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto2: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.proto2 != 0 {
-      try visitor.visitSingularInt32Field(value: self.proto2, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.proto2 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto2, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto2) -> Bool {
     if lhs.proto2 != rhs.proto2 {return false}
@@ -33159,12 +33135,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3Defau
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.proto3DefaultValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.proto3DefaultValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.proto3DefaultValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3DefaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3DefaultValue) -> Bool {
     if lhs.proto3DefaultValue != rhs.proto3DefaultValue {return false}
@@ -33191,12 +33165,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3Optio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.proto3Optional != 0 {
-      try visitor.visitSingularInt32Field(value: self.proto3Optional, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.proto3Optional }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3Optional, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3Optional) -> Bool {
     if lhs.proto3Optional != rhs.proto3Optional {return false}
@@ -33223,12 +33195,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPI
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufApiversionCheck != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufApiversionCheck, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufApiversionCheck }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck) -> Bool {
     if lhs.protobufApiversionCheck != rhs.protobufApiversionCheck {return false}
@@ -33255,12 +33225,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPI
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufApiversion3 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufApiversion3, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufApiversion3 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_3, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_3) -> Bool {
     if lhs.protobufApiversion3 != rhs.protobufApiversion3 {return false}
@@ -33287,12 +33255,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBoo
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufBool != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufBool, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufBool }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBool, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBool) -> Bool {
     if lhs.protobufBool != rhs.protobufBool {return false}
@@ -33319,12 +33285,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufByt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufBytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufBytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufBytes }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBytes) -> Bool {
     if lhs.protobufBytes != rhs.protobufBytes {return false}
@@ -33351,12 +33315,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufDou
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufDouble != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufDouble, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufDouble }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufDouble, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufDouble) -> Bool {
     if lhs.protobufDouble != rhs.protobufDouble {return false}
@@ -33383,12 +33345,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufEnu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufEnumMap != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufEnumMap, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufEnumMap }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufEnumMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufEnumMap) -> Bool {
     if lhs.protobufEnumMap != rhs.protobufEnumMap {return false}
@@ -33415,12 +33375,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufExt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufExtension != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufExtension, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufExtension }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufExtension) -> Bool {
     if lhs.protobufExtension != rhs.protobufExtension {return false}
@@ -33447,12 +33405,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFix
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufFixed32 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufFixed32, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufFixed32 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed32) -> Bool {
     if lhs.protobufFixed32 != rhs.protobufFixed32 {return false}
@@ -33479,12 +33435,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFix
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufFixed64 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufFixed64, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufFixed64 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed64) -> Bool {
     if lhs.protobufFixed64 != rhs.protobufFixed64 {return false}
@@ -33511,12 +33465,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFlo
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufFloat != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufFloat, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufFloat }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFloat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFloat) -> Bool {
     if lhs.protobufFloat != rhs.protobufFloat {return false}
@@ -33543,12 +33495,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufInt32 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufInt32, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufInt32 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt32) -> Bool {
     if lhs.protobufInt32 != rhs.protobufInt32 {return false}
@@ -33575,12 +33525,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufInt64 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufInt64, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufInt64 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt64) -> Bool {
     if lhs.protobufInt64 != rhs.protobufInt64 {return false}
@@ -33607,12 +33555,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMap
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufMap != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufMap, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufMap }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMap) -> Bool {
     if lhs.protobufMap != rhs.protobufMap {return false}
@@ -33639,12 +33585,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufMessageMap != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufMessageMap, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufMessageMap }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMessageMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMessageMap) -> Bool {
     if lhs.protobufMessageMap != rhs.protobufMessageMap {return false}
@@ -33671,12 +33615,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufSfixed32 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufSfixed32, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufSfixed32 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed32) -> Bool {
     if lhs.protobufSfixed32 != rhs.protobufSfixed32 {return false}
@@ -33703,12 +33645,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufSfixed64 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufSfixed64, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufSfixed64 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed64) -> Bool {
     if lhs.protobufSfixed64 != rhs.protobufSfixed64 {return false}
@@ -33735,12 +33675,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSIn
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufSint32 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufSint32, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufSint32 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt32) -> Bool {
     if lhs.protobufSint32 != rhs.protobufSint32 {return false}
@@ -33767,12 +33705,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSIn
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufSint64 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufSint64, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufSint64 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt64) -> Bool {
     if lhs.protobufSint64 != rhs.protobufSint64 {return false}
@@ -33799,12 +33735,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufStr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufString != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufString, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufString }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufString) -> Bool {
     if lhs.protobufString != rhs.protobufString {return false}
@@ -33831,12 +33765,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUIn
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufUint32 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufUint32, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufUint32 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt32) -> Bool {
     if lhs.protobufUint32 != rhs.protobufUint32 {return false}
@@ -33863,12 +33795,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUIn
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufUint64 != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufUint64, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufUint64 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt64) -> Bool {
     if lhs.protobufUint64 != rhs.protobufUint64 {return false}
@@ -33895,12 +33825,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_ex
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufExtensionFieldValues != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufExtensionFieldValues, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufExtensionFieldValues }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues) -> Bool {
     if lhs.protobufExtensionFieldValues != rhs.protobufExtensionFieldValues {return false}
@@ -33927,12 +33855,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_fi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufFieldNumber != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufFieldNumber, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufFieldNumber }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_fieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_fieldNumber) -> Bool {
     if lhs.protobufFieldNumber != rhs.protobufFieldNumber {return false}
@@ -33959,12 +33885,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_ge
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufGeneratedIsEqualTo != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufGeneratedIsEqualTo, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufGeneratedIsEqualTo }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo) -> Bool {
     if lhs.protobufGeneratedIsEqualTo != rhs.protobufGeneratedIsEqualTo {return false}
@@ -33991,12 +33915,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_na
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufNameMap != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufNameMap, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufNameMap }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_nameMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_nameMap) -> Bool {
     if lhs.protobufNameMap != rhs.protobufNameMap {return false}
@@ -34023,12 +33945,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_ne
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufNewField != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufNewField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufNewField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_newField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_newField) -> Bool {
     if lhs.protobufNewField != rhs.protobufNewField {return false}
@@ -34055,12 +33975,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_pa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protobufPackage != 0 {
-      try visitor.visitSingularInt32Field(value: self.protobufPackage, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protobufPackage }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_package, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_package) -> Bool {
     if lhs.protobufPackage != rhs.protobufPackage {return false}
@@ -34087,12 +34005,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protocolMes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`protocol` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`protocol`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`protocol` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protocolMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protocolMessage) -> Bool {
     if lhs.`protocol` != rhs.`protocol` {return false}
@@ -34119,12 +34035,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoFieldN
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protoFieldName != 0 {
-      try visitor.visitSingularInt32Field(value: self.protoFieldName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protoFieldName }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoFieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoFieldName) -> Bool {
     if lhs.protoFieldName != rhs.protoFieldName {return false}
@@ -34151,12 +34065,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protoMessageName != 0 {
-      try visitor.visitSingularInt32Field(value: self.protoMessageName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protoMessageName }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageNameMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageNameMessage) -> Bool {
     if lhs.protoMessageName != rhs.protoMessageName {return false}
@@ -34183,12 +34095,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtoNamePr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protoNameProviding != 0 {
-      try visitor.visitSingularInt32Field(value: self.protoNameProviding, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protoNameProviding }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtoNameProviding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtoNameProviding) -> Bool {
     if lhs.protoNameProviding != rhs.protoNameProviding {return false}
@@ -34215,12 +34125,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoPaths:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.protoPaths != 0 {
-      try visitor.visitSingularInt32Field(value: self.protoPaths, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protoPaths }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoPaths, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoPaths) -> Bool {
     if lhs.protoPaths != rhs.protoPaths {return false}
@@ -34247,12 +34155,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicMessa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`public` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`public`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`public` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicMessage) -> Bool {
     if lhs.`public` != rhs.`public` {return false}
@@ -34279,12 +34185,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicDepen
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.publicDependency != 0 {
-      try visitor.visitSingularInt32Field(value: self.publicDependency, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.publicDependency }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicDependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicDependency) -> Bool {
     if lhs.publicDependency != rhs.publicDependency {return false}
@@ -34311,12 +34215,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBoolValu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putBoolValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.putBoolValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putBoolValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBoolValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBoolValue) -> Bool {
     if lhs.putBoolValue != rhs.putBoolValue {return false}
@@ -34343,12 +34245,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBytesVal
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putBytesValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.putBytesValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putBytesValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBytesValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBytesValue) -> Bool {
     if lhs.putBytesValue != rhs.putBytesValue {return false}
@@ -34375,12 +34275,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putDoubleVa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putDoubleValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.putDoubleValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putDoubleValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putDoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putDoubleValue) -> Bool {
     if lhs.putDoubleValue != rhs.putDoubleValue {return false}
@@ -34407,12 +34305,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putEnumValu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putEnumValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.putEnumValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putEnumValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putEnumValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putEnumValue) -> Bool {
     if lhs.putEnumValue != rhs.putEnumValue {return false}
@@ -34439,12 +34335,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUIn
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putFixedUint32 != 0 {
-      try visitor.visitSingularInt32Field(value: self.putFixedUint32, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putFixedUint32 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt32) -> Bool {
     if lhs.putFixedUint32 != rhs.putFixedUint32 {return false}
@@ -34471,12 +34365,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUIn
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putFixedUint64 != 0 {
-      try visitor.visitSingularInt32Field(value: self.putFixedUint64, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putFixedUint64 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt64) -> Bool {
     if lhs.putFixedUint64 != rhs.putFixedUint64 {return false}
@@ -34503,12 +34395,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFloatVal
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putFloatValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.putFloatValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putFloatValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFloatValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFloatValue) -> Bool {
     if lhs.putFloatValue != rhs.putFloatValue {return false}
@@ -34535,12 +34425,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putInt64: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putInt64 != 0 {
-      try visitor.visitSingularInt32Field(value: self.putInt64, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putInt64 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putInt64) -> Bool {
     if lhs.putInt64 != rhs.putInt64 {return false}
@@ -34567,12 +34455,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putStringVa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putStringValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.putStringValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putStringValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putStringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putStringValue) -> Bool {
     if lhs.putStringValue != rhs.putStringValue {return false}
@@ -34599,12 +34485,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putUint64 != 0 {
-      try visitor.visitSingularInt32Field(value: self.putUint64, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putUint64 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64) -> Bool {
     if lhs.putUint64 != rhs.putUint64 {return false}
@@ -34631,12 +34515,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64He
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putUint64Hex != 0 {
-      try visitor.visitSingularInt32Field(value: self.putUint64Hex, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putUint64Hex }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64Hex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64Hex) -> Bool {
     if lhs.putUint64Hex != rhs.putUint64Hex {return false}
@@ -34663,12 +34545,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putVarInt:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putVarInt != 0 {
-      try visitor.visitSingularInt32Field(value: self.putVarInt, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putVarInt }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putVarInt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putVarInt) -> Bool {
     if lhs.putVarInt != rhs.putVarInt {return false}
@@ -34695,12 +34575,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putZigZagVa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.putZigZagVarInt != 0 {
-      try visitor.visitSingularInt32Field(value: self.putZigZagVarInt, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.putZigZagVarInt }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putZigZagVarInt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putZigZagVarInt) -> Bool {
     if lhs.putZigZagVarInt != rhs.putZigZagVarInt {return false}
@@ -34727,12 +34605,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pyGenericSe
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.pyGenericServices != 0 {
-      try visitor.visitSingularInt32Field(value: self.pyGenericServices, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.pyGenericServices }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pyGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pyGenericServices) -> Bool {
     if lhs.pyGenericServices != rhs.pyGenericServices {return false}
@@ -34759,12 +34635,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.R: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.r != 0 {
-      try visitor.visitSingularInt32Field(value: self.r, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.r }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.R, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.R) -> Bool {
     if lhs.r != rhs.r {return false}
@@ -34791,12 +34665,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rawChars: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.rawChars != 0 {
-      try visitor.visitSingularInt32Field(value: self.rawChars, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.rawChars }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rawChars, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rawChars) -> Bool {
     if lhs.rawChars != rhs.rawChars {return false}
@@ -34823,12 +34695,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawRepresen
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.rawRepresentable != 0 {
-      try visitor.visitSingularInt32Field(value: self.rawRepresentable, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.rawRepresentable }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawRepresentable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawRepresentable) -> Bool {
     if lhs.rawRepresentable != rhs.rawRepresentable {return false}
@@ -34855,12 +34725,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawValue: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.rawValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.rawValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.rawValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawValue) -> Bool {
     if lhs.rawValue != rhs.rawValue {return false}
@@ -34887,12 +34755,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.read4HexDig
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.read4HexDigits != 0 {
-      try visitor.visitSingularInt32Field(value: self.read4HexDigits, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.read4HexDigits }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.read4HexDigits, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.read4HexDigits) -> Bool {
     if lhs.read4HexDigits != rhs.read4HexDigits {return false}
@@ -34919,12 +34785,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.readBytes:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.readBytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.readBytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.readBytes }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.readBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.readBytes) -> Bool {
     if lhs.readBytes != rhs.readBytes {return false}
@@ -34951,12 +34815,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.register: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.register != 0 {
-      try visitor.visitSingularInt32Field(value: self.register, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.register }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.register, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.register) -> Bool {
     if lhs.register != rhs.register {return false}
@@ -34983,12 +34845,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeated: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.repeated != 0 {
-      try visitor.visitSingularInt32Field(value: self.repeated, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeated }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeated) -> Bool {
     if lhs.repeated != rhs.repeated {return false}
@@ -34997,6 +34857,126 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeated: S
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedBool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedBool"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedBool"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedBool) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedBool }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedBool, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedBool) -> Bool {
+    if lhs.repeatedBool != rhs.repeatedBool {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedBytes"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedBytes"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedBytes) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedBytes }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedBytes) -> Bool {
+    if lhs.repeatedBytes != rhs.repeatedBytes {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedDouble"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedDouble"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedDouble) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedDouble }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedDouble, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedDouble) -> Bool {
+    if lhs.repeatedDouble != rhs.repeatedDouble {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedEnum"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedEnum"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedEnum) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedEnum }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedEnum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedEnum) -> Bool {
+    if lhs.repeatedEnum != rhs.repeatedEnum {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedEnumExtensionField"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -35015,12 +34995,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedEnu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.repeatedEnumExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.repeatedEnumExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedEnumExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField) -> Bool {
     if lhs.repeatedEnumExtensionField != rhs.repeatedEnumExtensionField {return false}
@@ -35047,12 +35025,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedExt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.repeatedExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.repeatedExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedExtensionField) -> Bool {
     if lhs.repeatedExtensionField != rhs.repeatedExtensionField {return false}
@@ -35079,12 +35055,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFie
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.repeatedFieldEncoding != 0 {
-      try visitor.visitSingularInt32Field(value: self.repeatedFieldEncoding, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedFieldEncoding }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFieldEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFieldEncoding) -> Bool {
     if lhs.repeatedFieldEncoding != rhs.repeatedFieldEncoding {return false}
@@ -35093,6 +35067,126 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFie
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedFixed32"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedFixed32"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedFixed32) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedFixed32 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFixed32) -> Bool {
+    if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedFixed64"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedFixed64"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedFixed64) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedFixed64 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFixed64) -> Bool {
+    if lhs.repeatedFixed64 != rhs.repeatedFixed64 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFloat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedFloat"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedFloat"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedFloat) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedFloat }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFloat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFloat) -> Bool {
+    if lhs.repeatedFloat != rhs.repeatedFloat {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedGroup"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedGroup"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedGroup) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedGroup }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedGroup, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedGroup) -> Bool {
+    if lhs.repeatedGroup != rhs.repeatedGroup {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedGroupExtensionField"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -35111,12 +35205,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.repeatedGroupExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.repeatedGroupExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedGroupExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField) -> Bool {
     if lhs.repeatedGroupExtensionField != rhs.repeatedGroupExtensionField {return false}
@@ -35125,6 +35217,96 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGro
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedInt32"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedInt32"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedInt32) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedInt32 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedInt32) -> Bool {
+    if lhs.repeatedInt32 != rhs.repeatedInt32 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedInt64"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedInt64"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedInt64) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedInt64 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedInt64) -> Bool {
+    if lhs.repeatedInt64 != rhs.repeatedInt64 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedMessage"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedMessage"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedMessage) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedMessage }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedMessage) -> Bool {
+    if lhs.repeatedMessage != rhs.repeatedMessage {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedMessageExtensionField"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -35143,12 +35325,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.repeatedMessageExtensionField != 0 {
-      try visitor.visitSingularInt32Field(value: self.repeatedMessageExtensionField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedMessageExtensionField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField) -> Bool {
     if lhs.repeatedMessageExtensionField != rhs.repeatedMessageExtensionField {return false}
@@ -35157,6 +35337,216 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMes
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedSFixed32"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedSFixed32"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedSfixed32) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedSfixed32 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSFixed32) -> Bool {
+    if lhs.repeatedSfixed32 != rhs.repeatedSfixed32 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedSFixed64"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedSFixed64"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedSfixed64) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedSfixed64 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSFixed64) -> Bool {
+    if lhs.repeatedSfixed64 != rhs.repeatedSfixed64 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedSInt32"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedSInt32"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedSint32) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedSint32 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSInt32) -> Bool {
+    if lhs.repeatedSint32 != rhs.repeatedSint32 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedSInt64"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedSInt64"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedSint64) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedSint64 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedSInt64) -> Bool {
+    if lhs.repeatedSint64 != rhs.repeatedSint64 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedString"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedString"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedString) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedString }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedString) -> Bool {
+    if lhs.repeatedString != rhs.repeatedString {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedUInt32"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedUInt32"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedUint32) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedUint32 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedUInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedUInt32) -> Bool {
+    if lhs.repeatedUint32 != rhs.repeatedUint32 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedUInt64"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "repeatedUInt64"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeatedUint64) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeatedUint64 }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedUInt64) -> Bool {
+    if lhs.repeatedUint64 != rhs.repeatedUint64 {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeating"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -35175,12 +35565,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeating:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.repeating != 0 {
-      try visitor.visitSingularInt32Field(value: self.repeating, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.repeating }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeating, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeating) -> Bool {
     if lhs.repeating != rhs.repeating {return false}
@@ -35207,12 +35595,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestStre
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.requestStreaming != 0 {
-      try visitor.visitSingularInt32Field(value: self.requestStreaming, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.requestStreaming }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestStreaming) -> Bool {
     if lhs.requestStreaming != rhs.requestStreaming {return false}
@@ -35239,12 +35625,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestType
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.requestTypeURL != 0 {
-      try visitor.visitSingularInt32Field(value: self.requestTypeURL, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.requestTypeURL }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestTypeURL) -> Bool {
     if lhs.requestTypeURL != rhs.requestTypeURL {return false}
@@ -35271,12 +35655,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requiredSiz
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.requiredSize != 0 {
-      try visitor.visitSingularInt32Field(value: self.requiredSize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.requiredSize }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requiredSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requiredSize) -> Bool {
     if lhs.requiredSize != rhs.requiredSize {return false}
@@ -35303,12 +35685,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseStr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.responseStreaming != 0 {
-      try visitor.visitSingularInt32Field(value: self.responseStreaming, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.responseStreaming }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseStreaming) -> Bool {
     if lhs.responseStreaming != rhs.responseStreaming {return false}
@@ -35335,12 +35715,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseTyp
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.responseTypeURL != 0 {
-      try visitor.visitSingularInt32Field(value: self.responseTypeURL, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.responseTypeURL }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseTypeURL) -> Bool {
     if lhs.responseTypeURL != rhs.responseTypeURL {return false}
@@ -35367,12 +35745,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.result: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.result != 0 {
-      try visitor.visitSingularInt32Field(value: self.result, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.result }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.result, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.result) -> Bool {
     if lhs.result != rhs.result {return false}
@@ -35399,12 +35775,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.retention:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.retention != 0 {
-      try visitor.visitSingularInt32Field(value: self.retention, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.retention }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.retention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.retention) -> Bool {
     if lhs.retention != rhs.retention {return false}
@@ -35431,12 +35805,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rethrowsMes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`rethrows` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`rethrows`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`rethrows` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rethrowsMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rethrowsMessage) -> Bool {
     if lhs.`rethrows` != rhs.`rethrows` {return false}
@@ -35463,12 +35835,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.returnMessa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`return` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`return`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`return` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.returnMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.returnMessage) -> Bool {
     if lhs.`return` != rhs.`return` {return false}
@@ -35495,12 +35865,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ReturnType:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.returnType != 0 {
-      try visitor.visitSingularInt32Field(value: self.returnType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.returnType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ReturnType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ReturnType) -> Bool {
     if lhs.returnType != rhs.returnType {return false}
@@ -35527,24 +35895,562 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.revision != 0 {
-      try visitor.visitSingularInt32Field(value: self.revision, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.revision }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision) -> Bool {
+    if lhs.revision != rhs.revision {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rhs"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "rhs"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.rhs) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.rhs }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs) -> Bool {
+    if lhs.rhs != rhs.rhs {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".root"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "root"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.root) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.root }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root) -> Bool {
+    if lhs.root != rhs.root {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rubyPackage"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "rubyPackage"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.rubyPackage) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.rubyPackage }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage) -> Bool {
+    if lhs.rubyPackage != rhs.rubyPackage {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".s"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "s"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.s) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.s }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s) -> Bool {
+    if lhs.s != rhs.s {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawBackslash"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "sawBackslash"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.sawBackslash) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sawBackslash }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash) -> Bool {
+    if lhs.sawBackslash != rhs.sawBackslash {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection4Characters"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "sawSection4Characters"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.sawSection4Characters) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sawSection4Characters }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters) -> Bool {
+    if lhs.sawSection4Characters != rhs.sawSection4Characters {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection5Characters"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "sawSection5Characters"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.sawSection5Characters) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sawSection5Characters }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters) -> Bool {
+    if lhs.sawSection5Characters != rhs.sawSection5Characters {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".scanner"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "scanner"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.scanner) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.scanner }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner) -> Bool {
+    if lhs.scanner != rhs.scanner {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".seconds"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "seconds"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.seconds) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.seconds }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds) -> Bool {
+    if lhs.seconds != rhs.seconds {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".self"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "self"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.self_p) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.self_p }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage) -> Bool {
+    if lhs.self_p != rhs.self_p {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".semantic"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "semantic"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.semantic) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.semantic }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic) -> Bool {
+    if lhs.semantic != rhs.semantic {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Sendable"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "Sendable"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.sendable) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sendable }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage) -> Bool {
+    if lhs.sendable != rhs.sendable {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".separator"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "separator"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.separator) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.separator }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator) -> Bool {
+    if lhs.separator != rhs.separator {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serialize"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "serialize"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serialize) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.serialize }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize) -> Bool {
+    if lhs.serialize != rhs.serialize {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedBytes"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "serializedBytes"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedBytes) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.serializedBytes }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes) -> Bool {
+    if lhs.serializedBytes != rhs.serializedBytes {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedData"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "serializedData"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedData) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.serializedData }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData) -> Bool {
+    if lhs.serializedData != rhs.serializedData {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedSize"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "serializedSize"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedSize) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.serializedSize }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize) -> Bool {
+    if lhs.serializedSize != rhs.serializedSize {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serverStreaming"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "serverStreaming"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serverStreaming) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.serverStreaming }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision) -> Bool {
-    if lhs.revision != rhs.revision {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming) -> Bool {
+    if lhs.serverStreaming != rhs.serverStreaming {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rhs"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".service"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "rhs"),
+    1: .same(proto: "service"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35553,30 +36459,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs: SwiftP
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.rhs) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.service) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.rhs != 0 {
-      try visitor.visitSingularInt32Field(value: self.rhs, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.service }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs) -> Bool {
-    if lhs.rhs != rhs.rhs {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service) -> Bool {
+    if lhs.service != rhs.service {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".root"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ServiceDescriptorProto"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "root"),
+    1: .same(proto: "ServiceDescriptorProto"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35585,30 +36489,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root: Swift
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.root) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serviceDescriptorProto) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.root != 0 {
-      try visitor.visitSingularInt32Field(value: self.root, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.serviceDescriptorProto }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root) -> Bool {
-    if lhs.root != rhs.root {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceDescriptorProto) -> Bool {
+    if lhs.serviceDescriptorProto != rhs.serviceDescriptorProto {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rubyPackage"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ServiceOptions"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "rubyPackage"),
+    1: .same(proto: "ServiceOptions"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35617,30 +36519,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.rubyPackage) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serviceOptions) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.rubyPackage != 0 {
-      try visitor.visitSingularInt32Field(value: self.rubyPackage, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.serviceOptions }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage) -> Bool {
-    if lhs.rubyPackage != rhs.rubyPackage {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceOptions) -> Bool {
+    if lhs.serviceOptions != rhs.serviceOptions {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".s"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".set"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "s"),
+    1: .same(proto: "set"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35649,30 +36549,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s: SwiftPro
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.s) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.set) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.s != 0 {
-      try visitor.visitSingularInt32Field(value: self.s, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.set }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s) -> Bool {
-    if lhs.s != rhs.s {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set) -> Bool {
+    if lhs.set != rhs.set {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawBackslash"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".setExtensionValue"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "sawBackslash"),
+    1: .same(proto: "setExtensionValue"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35681,30 +36579,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslas
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.sawBackslash) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.setExtensionValue) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.sawBackslash != 0 {
-      try visitor.visitSingularInt32Field(value: self.sawBackslash, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.setExtensionValue }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash) -> Bool {
-    if lhs.sawBackslash != rhs.sawBackslash {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue) -> Bool {
+    if lhs.setExtensionValue != rhs.setExtensionValue {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection4Characters"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".shift"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "sawSection4Characters"),
+    1: .same(proto: "shift"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35713,30 +36609,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.sawSection4Characters) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.shift) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.sawSection4Characters != 0 {
-      try visitor.visitSingularInt32Field(value: self.sawSection4Characters, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.shift }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters) -> Bool {
-    if lhs.sawSection4Characters != rhs.sawSection4Characters {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift) -> Bool {
+    if lhs.shift != rhs.shift {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection5Characters"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".SimpleExtensionMap"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "sawSection5Characters"),
+    1: .same(proto: "SimpleExtensionMap"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35745,30 +36639,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.sawSection5Characters) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.simpleExtensionMap) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.sawSection5Characters != 0 {
-      try visitor.visitSingularInt32Field(value: self.sawSection5Characters, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.simpleExtensionMap }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters) -> Bool {
-    if lhs.sawSection5Characters != rhs.sawSection5Characters {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap) -> Bool {
+    if lhs.simpleExtensionMap != rhs.simpleExtensionMap {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".scanner"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularBool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularBool"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "scanner"),
+    1: .same(proto: "singularBool"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35777,30 +36669,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner: Sw
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.scanner) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularBool) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.scanner != 0 {
-      try visitor.visitSingularInt32Field(value: self.scanner, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularBool }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner) -> Bool {
-    if lhs.scanner != rhs.scanner {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularBool, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularBool) -> Bool {
+    if lhs.singularBool != rhs.singularBool {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".seconds"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularBytes"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "seconds"),
+    1: .same(proto: "singularBytes"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35809,30 +36699,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds: Sw
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.seconds) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularBytes) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.seconds != 0 {
-      try visitor.visitSingularInt32Field(value: self.seconds, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularBytes }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds) -> Bool {
-    if lhs.seconds != rhs.seconds {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularBytes) -> Bool {
+    if lhs.singularBytes != rhs.singularBytes {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".self"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularDouble"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "self"),
+    1: .same(proto: "singularDouble"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35841,30 +36729,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.self_p) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularDouble) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.self_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.self_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularDouble }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage) -> Bool {
-    if lhs.self_p != rhs.self_p {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularDouble, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularDouble) -> Bool {
+    if lhs.singularDouble != rhs.singularDouble {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".semantic"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularEnum"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "semantic"),
+    1: .same(proto: "singularEnum"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35873,30 +36759,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic: S
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.semantic) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularEnum) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.semantic != 0 {
-      try visitor.visitSingularInt32Field(value: self.semantic, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularEnum }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic) -> Bool {
-    if lhs.semantic != rhs.semantic {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularEnum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularEnum) -> Bool {
+    if lhs.singularEnum != rhs.singularEnum {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Sendable"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularFixed32"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "Sendable"),
+    1: .same(proto: "singularFixed32"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35905,30 +36789,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMes
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.sendable) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularFixed32) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.sendable != 0 {
-      try visitor.visitSingularInt32Field(value: self.sendable, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularFixed32 }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage) -> Bool {
-    if lhs.sendable != rhs.sendable {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularFixed32) -> Bool {
+    if lhs.singularFixed32 != rhs.singularFixed32 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".separator"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularFixed64"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "separator"),
+    1: .same(proto: "singularFixed64"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35937,30 +36819,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator:
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.separator) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularFixed64) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.separator != 0 {
-      try visitor.visitSingularInt32Field(value: self.separator, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularFixed64 }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator) -> Bool {
-    if lhs.separator != rhs.separator {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularFixed64) -> Bool {
+    if lhs.singularFixed64 != rhs.singularFixed64 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serialize"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularFloat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularFloat"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "serialize"),
+    1: .same(proto: "singularFloat"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -35969,30 +36849,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize:
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serialize) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularFloat) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.serialize != 0 {
-      try visitor.visitSingularInt32Field(value: self.serialize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularFloat }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize) -> Bool {
-    if lhs.serialize != rhs.serialize {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularFloat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularFloat) -> Bool {
+    if lhs.singularFloat != rhs.singularFloat {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedBytes"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularGroup"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "serializedBytes"),
+    1: .same(proto: "singularGroup"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36001,30 +36879,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedB
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedBytes) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularGroup) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.serializedBytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.serializedBytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularGroup }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes) -> Bool {
-    if lhs.serializedBytes != rhs.serializedBytes {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularGroup, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularGroup) -> Bool {
+    if lhs.singularGroup != rhs.singularGroup {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedData"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularInt32"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "serializedData"),
+    1: .same(proto: "singularInt32"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36033,30 +36909,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedD
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedData) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularInt32) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.serializedData != 0 {
-      try visitor.visitSingularInt32Field(value: self.serializedData, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularInt32 }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData) -> Bool {
-    if lhs.serializedData != rhs.serializedData {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularInt32) -> Bool {
+    if lhs.singularInt32 != rhs.singularInt32 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedSize"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularInt64"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "serializedSize"),
+    1: .same(proto: "singularInt64"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36065,30 +36939,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedS
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedSize) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularInt64) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.serializedSize != 0 {
-      try visitor.visitSingularInt32Field(value: self.serializedSize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularInt64 }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize) -> Bool {
-    if lhs.serializedSize != rhs.serializedSize {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularInt64) -> Bool {
+    if lhs.singularInt64 != rhs.singularInt64 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serverStreaming"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularMessage"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "serverStreaming"),
+    1: .same(proto: "singularMessage"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36097,30 +36969,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStrea
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serverStreaming) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularMessage) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.serverStreaming != 0 {
-      try visitor.visitSingularInt32Field(value: self.serverStreaming, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularMessage }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming) -> Bool {
-    if lhs.serverStreaming != rhs.serverStreaming {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularMessage) -> Bool {
+    if lhs.singularMessage != rhs.singularMessage {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".service"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularSFixed32"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "service"),
+    1: .same(proto: "singularSFixed32"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36129,30 +36999,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service: Sw
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.service) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularSfixed32) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.service != 0 {
-      try visitor.visitSingularInt32Field(value: self.service, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularSfixed32 }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service) -> Bool {
-    if lhs.service != rhs.service {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSFixed32) -> Bool {
+    if lhs.singularSfixed32 != rhs.singularSfixed32 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ServiceDescriptorProto"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularSFixed64"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "ServiceDescriptorProto"),
+    1: .same(proto: "singularSFixed64"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36161,30 +37029,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceDesc
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serviceDescriptorProto) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularSfixed64) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.serviceDescriptorProto != 0 {
-      try visitor.visitSingularInt32Field(value: self.serviceDescriptorProto, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularSfixed64 }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceDescriptorProto) -> Bool {
-    if lhs.serviceDescriptorProto != rhs.serviceDescriptorProto {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSFixed64) -> Bool {
+    if lhs.singularSfixed64 != rhs.singularSfixed64 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ServiceOptions"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularSInt32"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "ServiceOptions"),
+    1: .same(proto: "singularSInt32"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36193,30 +37059,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceOpti
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.serviceOptions) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularSint32) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.serviceOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.serviceOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularSint32 }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ServiceOptions) -> Bool {
-    if lhs.serviceOptions != rhs.serviceOptions {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSInt32) -> Bool {
+    if lhs.singularSint32 != rhs.singularSint32 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".set"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularSInt64"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "set"),
+    1: .same(proto: "singularSInt64"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36225,30 +37089,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set: SwiftP
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.set) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularSint64) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.set != 0 {
-      try visitor.visitSingularInt32Field(value: self.set, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularSint64 }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set) -> Bool {
-    if lhs.set != rhs.set {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularSInt64) -> Bool {
+    if lhs.singularSint64 != rhs.singularSint64 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".setExtensionValue"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularString"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "setExtensionValue"),
+    1: .same(proto: "singularString"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36257,30 +37119,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensio
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.setExtensionValue) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularString) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.setExtensionValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.setExtensionValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularString }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue) -> Bool {
-    if lhs.setExtensionValue != rhs.setExtensionValue {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularString) -> Bool {
+    if lhs.singularString != rhs.singularString {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".shift"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularUInt32"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "shift"),
+    1: .same(proto: "singularUInt32"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36289,30 +37149,28 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift: Swif
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.shift) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularUint32) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.shift != 0 {
-      try visitor.visitSingularInt32Field(value: self.shift, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularUint32 }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift) -> Bool {
-    if lhs.shift != rhs.shift {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularUInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularUInt32) -> Bool {
+    if lhs.singularUint32 != rhs.singularUint32 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
-extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
-  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".SimpleExtensionMap"
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".singularUInt64"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
-    1: .same(proto: "SimpleExtensionMap"),
+    1: .same(proto: "singularUInt64"),
   ]
 
   mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@@ -36321,21 +37179,19 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExten
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeSingularInt32Field(value: &self.simpleExtensionMap) }()
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.singularUint64) }()
       default: break
       }
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.simpleExtensionMap != 0 {
-      try visitor.visitSingularInt32Field(value: self.simpleExtensionMap, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.singularUint64 }, fieldNumber: 1),
+  ]
 
-  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap) -> Bool {
-    if lhs.simpleExtensionMap != rhs.simpleExtensionMap {return false}
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.singularUInt64) -> Bool {
+    if lhs.singularUint64 != rhs.singularUint64 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
@@ -36359,12 +37215,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.size: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.size != 0 {
-      try visitor.visitSingularInt32Field(value: self.size, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.size }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.size, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.size) -> Bool {
     if lhs.size != rhs.size {return false}
@@ -36391,12 +37245,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sizer: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.sizer != 0 {
-      try visitor.visitSingularInt32Field(value: self.sizer, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sizer }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sizer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sizer) -> Bool {
     if lhs.sizer != rhs.sizer {return false}
@@ -36423,12 +37275,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.source: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.source != 0 {
-      try visitor.visitSingularInt32Field(value: self.source, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.source }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.source, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.source) -> Bool {
     if lhs.source != rhs.source {return false}
@@ -36455,12 +37305,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceCodeI
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.sourceCodeInfo != 0 {
-      try visitor.visitSingularInt32Field(value: self.sourceCodeInfo, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sourceCodeInfo }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceCodeInfo) -> Bool {
     if lhs.sourceCodeInfo != rhs.sourceCodeInfo {return false}
@@ -36487,12 +37335,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceConte
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.sourceContext != 0 {
-      try visitor.visitSingularInt32Field(value: self.sourceContext, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sourceContext }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceContext) -> Bool {
     if lhs.sourceContext != rhs.sourceContext {return false}
@@ -36519,12 +37365,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceEncod
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.sourceEncoding != 0 {
-      try visitor.visitSingularInt32Field(value: self.sourceEncoding, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sourceEncoding }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceEncoding) -> Bool {
     if lhs.sourceEncoding != rhs.sourceEncoding {return false}
@@ -36551,12 +37395,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceFile:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.sourceFile != 0 {
-      try visitor.visitSingularInt32Field(value: self.sourceFile, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sourceFile }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceFile, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceFile) -> Bool {
     if lhs.sourceFile != rhs.sourceFile {return false}
@@ -36583,12 +37425,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.span: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.span != 0 {
-      try visitor.visitSingularInt32Field(value: self.span, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.span }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.span, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.span) -> Bool {
     if lhs.span != rhs.span {return false}
@@ -36615,12 +37455,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.split: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.split != 0 {
-      try visitor.visitSingularInt32Field(value: self.split, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.split }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.split, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.split) -> Bool {
     if lhs.split != rhs.split {return false}
@@ -36647,12 +37485,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.start: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.start != 0 {
-      try visitor.visitSingularInt32Field(value: self.start, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.start }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.start, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.start) -> Bool {
     if lhs.start != rhs.start {return false}
@@ -36679,12 +37515,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArray:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.startArray != 0 {
-      try visitor.visitSingularInt32Field(value: self.startArray, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.startArray }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArray, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArray) -> Bool {
     if lhs.startArray != rhs.startArray {return false}
@@ -36711,12 +37545,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArrayO
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.startArrayObject != 0 {
-      try visitor.visitSingularInt32Field(value: self.startArrayObject, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.startArrayObject }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArrayObject, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArrayObject) -> Bool {
     if lhs.startArrayObject != rhs.startArrayObject {return false}
@@ -36743,12 +37575,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startField:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.startField != 0 {
-      try visitor.visitSingularInt32Field(value: self.startField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.startField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startField) -> Bool {
     if lhs.startField != rhs.startField {return false}
@@ -36775,12 +37605,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startIndex:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.startIndex != 0 {
-      try visitor.visitSingularInt32Field(value: self.startIndex, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.startIndex }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startIndex) -> Bool {
     if lhs.startIndex != rhs.startIndex {return false}
@@ -36807,12 +37635,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.startMessageField != 0 {
-      try visitor.visitSingularInt32Field(value: self.startMessageField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.startMessageField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startMessageField) -> Bool {
     if lhs.startMessageField != rhs.startMessageField {return false}
@@ -36839,12 +37665,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startObject
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.startObject != 0 {
-      try visitor.visitSingularInt32Field(value: self.startObject, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.startObject }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startObject, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startObject) -> Bool {
     if lhs.startObject != rhs.startObject {return false}
@@ -36871,12 +37695,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startRegula
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.startRegularField != 0 {
-      try visitor.visitSingularInt32Field(value: self.startRegularField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.startRegularField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startRegularField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startRegularField) -> Bool {
     if lhs.startRegularField != rhs.startRegularField {return false}
@@ -36903,12 +37725,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.state: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.state != 0 {
-      try visitor.visitSingularInt32Field(value: self.state, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.state }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.state, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.state) -> Bool {
     if lhs.state != rhs.state {return false}
@@ -36935,12 +37755,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.staticMessa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`static` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`static`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`static` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.staticMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.staticMessage) -> Bool {
     if lhs.`static` != rhs.`static` {return false}
@@ -36967,12 +37785,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StaticStrin
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.staticString != 0 {
-      try visitor.visitSingularInt32Field(value: self.staticString, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.staticString }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StaticString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StaticString) -> Bool {
     if lhs.staticString != rhs.staticString {return false}
@@ -36999,12 +37815,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.storage: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.storage != 0 {
-      try visitor.visitSingularInt32Field(value: self.storage, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.storage }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.storage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.storage) -> Bool {
     if lhs.storage != rhs.storage {return false}
@@ -37031,12 +37845,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringMessa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.string != 0 {
-      try visitor.visitSingularInt32Field(value: self.string, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.string }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringMessage) -> Bool {
     if lhs.string != rhs.string {return false}
@@ -37063,12 +37875,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringLiter
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.stringLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.stringLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.stringLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringLiteral) -> Bool {
     if lhs.stringLiteral != rhs.stringLiteral {return false}
@@ -37095,12 +37905,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringLiter
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.stringLiteralType != 0 {
-      try visitor.visitSingularInt32Field(value: self.stringLiteralType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.stringLiteralType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringLiteralType) -> Bool {
     if lhs.stringLiteralType != rhs.stringLiteralType {return false}
@@ -37127,12 +37935,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringResul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.stringResult != 0 {
-      try visitor.visitSingularInt32Field(value: self.stringResult, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.stringResult }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringResult, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringResult) -> Bool {
     if lhs.stringResult != rhs.stringResult {return false}
@@ -37159,12 +37965,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringValue
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.stringValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.stringValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.stringValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringValue) -> Bool {
     if lhs.stringValue != rhs.stringValue {return false}
@@ -37191,12 +37995,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structMessa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`struct` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`struct`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`struct` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structMessage) -> Bool {
     if lhs.`struct` != rhs.`struct` {return false}
@@ -37223,12 +38025,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structValue
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.structValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.structValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.structValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structValue) -> Bool {
     if lhs.structValue != rhs.structValue {return false}
@@ -37255,12 +38055,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subDecoder:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.subDecoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.subDecoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.subDecoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subDecoder) -> Bool {
     if lhs.subDecoder != rhs.subDecoder {return false}
@@ -37287,12 +38085,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subscriptMe
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`subscript` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`subscript`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`subscript` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subscriptMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subscriptMessage) -> Bool {
     if lhs.`subscript` != rhs.`subscript` {return false}
@@ -37319,12 +38115,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subVisitor:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.subVisitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.subVisitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.subVisitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subVisitor) -> Bool {
     if lhs.subVisitor != rhs.subVisitor {return false}
@@ -37351,12 +38145,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.swift != 0 {
-      try visitor.visitSingularInt32Field(value: self.swift, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.swift }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftMessage) -> Bool {
     if lhs.swift != rhs.swift {return false}
@@ -37383,12 +38175,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.swiftPrefix
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.swiftPrefix != 0 {
-      try visitor.visitSingularInt32Field(value: self.swiftPrefix, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.swiftPrefix }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.swiftPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.swiftPrefix) -> Bool {
     if lhs.swiftPrefix != rhs.swiftPrefix {return false}
@@ -37415,12 +38205,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtob
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.swiftProtobufContiguousBytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.swiftProtobufContiguousBytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.swiftProtobufContiguousBytes }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufContiguousBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufContiguousBytes) -> Bool {
     if lhs.swiftProtobufContiguousBytes != rhs.swiftProtobufContiguousBytes {return false}
@@ -37447,12 +38235,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.syntax: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.syntax != 0 {
-      try visitor.visitSingularInt32Field(value: self.syntax, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.syntax }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.syntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.syntax) -> Bool {
     if lhs.syntax != rhs.syntax {return false}
@@ -37479,12 +38265,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.T: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.t != 0 {
-      try visitor.visitSingularInt32Field(value: self.t, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.t }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.T, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.T) -> Bool {
     if lhs.t != rhs.t {return false}
@@ -37511,12 +38295,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tag: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.tag != 0 {
-      try visitor.visitSingularInt32Field(value: self.tag, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.tag }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tag, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tag) -> Bool {
     if lhs.tag != rhs.tag {return false}
@@ -37543,12 +38325,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.targets: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.targets != 0 {
-      try visitor.visitSingularInt32Field(value: self.targets, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.targets }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.targets, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.targets) -> Bool {
     if lhs.targets != rhs.targets {return false}
@@ -37575,12 +38355,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.terminator:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.terminator != 0 {
-      try visitor.visitSingularInt32Field(value: self.terminator, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.terminator }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.terminator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.terminator) -> Bool {
     if lhs.terminator != rhs.terminator {return false}
@@ -37607,12 +38385,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.testDecoder
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.testDecoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.testDecoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.testDecoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.testDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.testDecoder) -> Bool {
     if lhs.testDecoder != rhs.testDecoder {return false}
@@ -37639,12 +38415,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.text: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.text != 0 {
-      try visitor.visitSingularInt32Field(value: self.text, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.text }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.text, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.text) -> Bool {
     if lhs.text != rhs.text {return false}
@@ -37671,12 +38445,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textDecoder
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.textDecoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.textDecoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.textDecoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textDecoder) -> Bool {
     if lhs.textDecoder != rhs.textDecoder {return false}
@@ -37703,12 +38475,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatD
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.textFormatDecoder != 0 {
-      try visitor.visitSingularInt32Field(value: self.textFormatDecoder, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.textFormatDecoder }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecoder) -> Bool {
     if lhs.textFormatDecoder != rhs.textFormatDecoder {return false}
@@ -37735,12 +38505,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatD
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.textFormatDecodingError != 0 {
-      try visitor.visitSingularInt32Field(value: self.textFormatDecodingError, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.textFormatDecodingError }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingError) -> Bool {
     if lhs.textFormatDecodingError != rhs.textFormatDecodingError {return false}
@@ -37767,12 +38535,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatD
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.textFormatDecodingOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.textFormatDecodingOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.textFormatDecodingOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions) -> Bool {
     if lhs.textFormatDecodingOptions != rhs.textFormatDecodingOptions {return false}
@@ -37799,12 +38565,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatE
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.textFormatEncodingOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.textFormatEncodingOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.textFormatEncodingOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions) -> Bool {
     if lhs.textFormatEncodingOptions != rhs.textFormatEncodingOptions {return false}
@@ -37831,12 +38595,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatE
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.textFormatEncodingVisitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.textFormatEncodingVisitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.textFormatEncodingVisitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor) -> Bool {
     if lhs.textFormatEncodingVisitor != rhs.textFormatEncodingVisitor {return false}
@@ -37863,12 +38625,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textFormatS
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.textFormatString != 0 {
-      try visitor.visitSingularInt32Field(value: self.textFormatString, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.textFormatString }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textFormatString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textFormatString) -> Bool {
     if lhs.textFormatString != rhs.textFormatString {return false}
@@ -37895,12 +38655,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwOrIgno
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.throwOrIgnore != 0 {
-      try visitor.visitSingularInt32Field(value: self.throwOrIgnore, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.throwOrIgnore }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwOrIgnore, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwOrIgnore) -> Bool {
     if lhs.throwOrIgnore != rhs.throwOrIgnore {return false}
@@ -37927,12 +38685,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwsMessa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`throws` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`throws`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`throws` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwsMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwsMessage) -> Bool {
     if lhs.`throws` != rhs.`throws` {return false}
@@ -37959,12 +38715,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterva
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.timeInterval != 0 {
-      try visitor.visitSingularInt32Field(value: self.timeInterval, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.timeInterval }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterval, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterval) -> Bool {
     if lhs.timeInterval != rhs.timeInterval {return false}
@@ -37991,12 +38745,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterva
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.timeIntervalSince1970 != 0 {
-      try visitor.visitSingularInt32Field(value: self.timeIntervalSince1970, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.timeIntervalSince1970 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSince1970, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSince1970) -> Bool {
     if lhs.timeIntervalSince1970 != rhs.timeIntervalSince1970 {return false}
@@ -38023,12 +38775,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterva
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.timeIntervalSinceReferenceDate != 0 {
-      try visitor.visitSingularInt32Field(value: self.timeIntervalSinceReferenceDate, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.timeIntervalSinceReferenceDate }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate) -> Bool {
     if lhs.timeIntervalSinceReferenceDate != rhs.timeIntervalSinceReferenceDate {return false}
@@ -38055,12 +38805,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Timestamp:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.timestamp != 0 {
-      try visitor.visitSingularInt32Field(value: self.timestamp, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.timestamp }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Timestamp, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Timestamp) -> Bool {
     if lhs.timestamp != rhs.timestamp {return false}
@@ -38069,6 +38817,36 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Timestamp:
   }
 }
 
+extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.toConcrete: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".toConcrete"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "toConcrete"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self.toConcrete) }()
+      default: break
+      }
+    }
+  }
+
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.toConcrete }, fieldNumber: 1),
+  ]
+
+
+  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.toConcrete, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.toConcrete) -> Bool {
+    if lhs.toConcrete != rhs.toConcrete {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.total: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".total"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -38087,12 +38865,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.total: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.total != 0 {
-      try visitor.visitSingularInt32Field(value: self.total, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.total }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.total, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.total) -> Bool {
     if lhs.total != rhs.total {return false}
@@ -38119,12 +38895,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalArrayD
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.totalArrayDepth != 0 {
-      try visitor.visitSingularInt32Field(value: self.totalArrayDepth, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.totalArrayDepth }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalArrayDepth, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalArrayDepth) -> Bool {
     if lhs.totalArrayDepth != rhs.totalArrayDepth {return false}
@@ -38151,12 +38925,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalSize:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.totalSize != 0 {
-      try visitor.visitSingularInt32Field(value: self.totalSize, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.totalSize }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalSize) -> Bool {
     if lhs.totalSize != rhs.totalSize {return false}
@@ -38183,12 +38955,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trailingCom
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.trailingComments != 0 {
-      try visitor.visitSingularInt32Field(value: self.trailingComments, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.trailingComments }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trailingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trailingComments) -> Bool {
     if lhs.trailingComments != rhs.trailingComments {return false}
@@ -38215,12 +38985,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.traverseMes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.traverse != 0 {
-      try visitor.visitSingularInt32Field(value: self.traverse, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.traverse }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.traverseMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.traverseMessage) -> Bool {
     if lhs.traverse != rhs.traverse {return false}
@@ -38247,12 +39015,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trueMessage
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`true` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`true`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`true` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trueMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trueMessage) -> Bool {
     if lhs.`true` != rhs.`true` {return false}
@@ -38279,12 +39045,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tryMessage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`try` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`try`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`try` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tryMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tryMessage) -> Bool {
     if lhs.`try` != rhs.`try` {return false}
@@ -38311,12 +39075,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.type: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.type != 0 {
-      try visitor.visitSingularInt32Field(value: self.type, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.type }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.type, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.type) -> Bool {
     if lhs.type != rhs.type {return false}
@@ -38343,12 +39105,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typealiasMe
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`typealias` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`typealias`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`typealias` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typealiasMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typealiasMessage) -> Bool {
     if lhs.`typealias` != rhs.`typealias` {return false}
@@ -38375,12 +39135,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TypeEnum: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.typeEnum != 0 {
-      try visitor.visitSingularInt32Field(value: self.typeEnum, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.typeEnum }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TypeEnum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TypeEnum) -> Bool {
     if lhs.typeEnum != rhs.typeEnum {return false}
@@ -38407,12 +39165,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeName: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.typeName != 0 {
-      try visitor.visitSingularInt32Field(value: self.typeName, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.typeName }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeName) -> Bool {
     if lhs.typeName != rhs.typeName {return false}
@@ -38439,12 +39195,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typePrefix:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.typePrefix != 0 {
-      try visitor.visitSingularInt32Field(value: self.typePrefix, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.typePrefix }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typePrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typePrefix) -> Bool {
     if lhs.typePrefix != rhs.typePrefix {return false}
@@ -38471,12 +39225,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeStart:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.typeStart != 0 {
-      try visitor.visitSingularInt32Field(value: self.typeStart, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.typeStart }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeStart) -> Bool {
     if lhs.typeStart != rhs.typeStart {return false}
@@ -38503,12 +39255,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeUnknown
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.typeUnknown != 0 {
-      try visitor.visitSingularInt32Field(value: self.typeUnknown, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.typeUnknown }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeUnknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeUnknown) -> Bool {
     if lhs.typeUnknown != rhs.typeUnknown {return false}
@@ -38535,12 +39285,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeURL: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.typeURL != 0 {
-      try visitor.visitSingularInt32Field(value: self.typeURL, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.typeURL }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeURL) -> Bool {
     if lhs.typeURL != rhs.typeURL {return false}
@@ -38567,12 +39315,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.uint32 != 0 {
-      try visitor.visitSingularInt32Field(value: self.uint32, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.uint32 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Message) -> Bool {
     if lhs.uint32 != rhs.uint32 {return false}
@@ -38599,12 +39345,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Value
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.uint32Value != 0 {
-      try visitor.visitSingularInt32Field(value: self.uint32Value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.uint32Value }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Value) -> Bool {
     if lhs.uint32Value != rhs.uint32Value {return false}
@@ -38631,12 +39375,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.uint64 != 0 {
-      try visitor.visitSingularInt32Field(value: self.uint64, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.uint64 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Message) -> Bool {
     if lhs.uint64 != rhs.uint64 {return false}
@@ -38663,12 +39405,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Value
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.uint64Value != 0 {
-      try visitor.visitSingularInt32Field(value: self.uint64Value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.uint64Value }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Value) -> Bool {
     if lhs.uint64Value != rhs.uint64Value {return false}
@@ -38695,12 +39435,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt8: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.uint8 != 0 {
-      try visitor.visitSingularInt32Field(value: self.uint8, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.uint8 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt8) -> Bool {
     if lhs.uint8 != rhs.uint8 {return false}
@@ -38727,12 +39465,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unchecked:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unchecked != 0 {
-      try visitor.visitSingularInt32Field(value: self.unchecked, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unchecked }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unchecked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unchecked) -> Bool {
     if lhs.unchecked != rhs.unchecked {return false}
@@ -38759,12 +39495,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScal
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unicodeScalarLiteral != 0 {
-      try visitor.visitSingularInt32Field(value: self.unicodeScalarLiteral, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unicodeScalarLiteral }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalarLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalarLiteral) -> Bool {
     if lhs.unicodeScalarLiteral != rhs.unicodeScalarLiteral {return false}
@@ -38791,12 +39525,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScal
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unicodeScalarLiteralType != 0 {
-      try visitor.visitSingularInt32Field(value: self.unicodeScalarLiteralType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unicodeScalarLiteralType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType) -> Bool {
     if lhs.unicodeScalarLiteralType != rhs.unicodeScalarLiteralType {return false}
@@ -38823,12 +39555,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScal
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unicodeScalars != 0 {
-      try visitor.visitSingularInt32Field(value: self.unicodeScalars, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unicodeScalars }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalars, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalars) -> Bool {
     if lhs.unicodeScalars != rhs.unicodeScalars {return false}
@@ -38855,12 +39585,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScal
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unicodeScalarView != 0 {
-      try visitor.visitSingularInt32Field(value: self.unicodeScalarView, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unicodeScalarView }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarView, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarView) -> Bool {
     if lhs.unicodeScalarView != rhs.unicodeScalarView {return false}
@@ -38887,12 +39615,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uninterpret
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.uninterpretedOption != 0 {
-      try visitor.visitSingularInt32Field(value: self.uninterpretedOption, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.uninterpretedOption }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uninterpretedOption, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uninterpretedOption) -> Bool {
     if lhs.uninterpretedOption != rhs.uninterpretedOption {return false}
@@ -38919,12 +39645,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.union: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.union != 0 {
-      try visitor.visitSingularInt32Field(value: self.union, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.union }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.union, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.union) -> Bool {
     if lhs.union != rhs.union {return false}
@@ -38951,12 +39675,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uniqueStora
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.uniqueStorage != 0 {
-      try visitor.visitSingularInt32Field(value: self.uniqueStorage, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.uniqueStorage }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uniqueStorage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uniqueStorage) -> Bool {
     if lhs.uniqueStorage != rhs.uniqueStorage {return false}
@@ -38983,12 +39705,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknown: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unknown != 0 {
-      try visitor.visitSingularInt32Field(value: self.unknown, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unknown }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknown) -> Bool {
     if lhs.unknown != rhs.unknown {return false}
@@ -39015,12 +39735,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknownFiel
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unknownFields_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.unknownFields_p, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unknownFields_p }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknownFieldsMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknownFieldsMessage) -> Bool {
     if lhs.unknownFields_p != rhs.unknownFields_p {return false}
@@ -39047,12 +39765,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnknownStor
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unknownStorage != 0 {
-      try visitor.visitSingularInt32Field(value: self.unknownStorage, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unknownStorage }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnknownStorage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnknownStorage) -> Bool {
     if lhs.unknownStorage != rhs.unknownStorage {return false}
@@ -39079,12 +39795,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unpackTo: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unpackTo != 0 {
-      try visitor.visitSingularInt32Field(value: self.unpackTo, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unpackTo }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unpackTo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unpackTo) -> Bool {
     if lhs.unpackTo != rhs.unpackTo {return false}
@@ -39111,12 +39825,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeBuffe
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unsafeBufferPointer != 0 {
-      try visitor.visitSingularInt32Field(value: self.unsafeBufferPointer, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unsafeBufferPointer }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeBufferPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeBufferPointer) -> Bool {
     if lhs.unsafeBufferPointer != rhs.unsafeBufferPointer {return false}
@@ -39143,12 +39855,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutab
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unsafeMutablePointer != 0 {
-      try visitor.visitSingularInt32Field(value: self.unsafeMutablePointer, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unsafeMutablePointer }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutablePointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutablePointer) -> Bool {
     if lhs.unsafeMutablePointer != rhs.unsafeMutablePointer {return false}
@@ -39175,12 +39885,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutab
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unsafeMutableRawBufferPointer != 0 {
-      try visitor.visitSingularInt32Field(value: self.unsafeMutableRawBufferPointer, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unsafeMutableRawBufferPointer }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer) -> Bool {
     if lhs.unsafeMutableRawBufferPointer != rhs.unsafeMutableRawBufferPointer {return false}
@@ -39207,12 +39915,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawBu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unsafeRawBufferPointer != 0 {
-      try visitor.visitSingularInt32Field(value: self.unsafeRawBufferPointer, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unsafeRawBufferPointer }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer) -> Bool {
     if lhs.unsafeRawBufferPointer != rhs.unsafeRawBufferPointer {return false}
@@ -39239,12 +39945,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawPo
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unsafeRawPointer != 0 {
-      try visitor.visitSingularInt32Field(value: self.unsafeRawPointer, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unsafeRawPointer }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawPointer) -> Bool {
     if lhs.unsafeRawPointer != rhs.unsafeRawPointer {return false}
@@ -39271,12 +39975,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unverifiedL
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.unverifiedLazy != 0 {
-      try visitor.visitSingularInt32Field(value: self.unverifiedLazy, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unverifiedLazy }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unverifiedLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unverifiedLazy) -> Bool {
     if lhs.unverifiedLazy != rhs.unverifiedLazy {return false}
@@ -39303,12 +40005,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.updatedOpti
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.updatedOptions != 0 {
-      try visitor.visitSingularInt32Field(value: self.updatedOptions, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.updatedOptions }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.updatedOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.updatedOptions) -> Bool {
     if lhs.updatedOptions != rhs.updatedOptions {return false}
@@ -39335,12 +40035,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.url: SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.url != 0 {
-      try visitor.visitSingularInt32Field(value: self.url, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.url }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.url, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.url) -> Bool {
     if lhs.url != rhs.url {return false}
@@ -39367,12 +40065,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.useDetermin
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.useDeterministicOrdering != 0 {
-      try visitor.visitSingularInt32Field(value: self.useDeterministicOrdering, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.useDeterministicOrdering }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.useDeterministicOrdering, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.useDeterministicOrdering) -> Bool {
     if lhs.useDeterministicOrdering != rhs.useDeterministicOrdering {return false}
@@ -39399,12 +40095,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.utf8 != 0 {
-      try visitor.visitSingularInt32Field(value: self.utf8, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.utf8 }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8) -> Bool {
     if lhs.utf8 != rhs.utf8 {return false}
@@ -39431,12 +40125,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Ptr: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.utf8Ptr != 0 {
-      try visitor.visitSingularInt32Field(value: self.utf8Ptr, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.utf8Ptr }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Ptr, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Ptr) -> Bool {
     if lhs.utf8Ptr != rhs.utf8Ptr {return false}
@@ -39463,12 +40155,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8ToDoubl
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.utf8ToDouble != 0 {
-      try visitor.visitSingularInt32Field(value: self.utf8ToDouble, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.utf8ToDouble }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8ToDouble, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8ToDouble) -> Bool {
     if lhs.utf8ToDouble != rhs.utf8ToDouble {return false}
@@ -39495,12 +40185,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Validat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.utf8Validation != 0 {
-      try visitor.visitSingularInt32Field(value: self.utf8Validation, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.utf8Validation }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Validation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Validation) -> Bool {
     if lhs.utf8Validation != rhs.utf8Validation {return false}
@@ -39527,12 +40215,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UTF8View: S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.utf8View != 0 {
-      try visitor.visitSingularInt32Field(value: self.utf8View, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.utf8View }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UTF8View, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UTF8View) -> Bool {
     if lhs.utf8View != rhs.utf8View {return false}
@@ -39559,12 +40245,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.v: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.v != 0 {
-      try visitor.visitSingularInt32Field(value: self.v, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.v }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.v, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.v) -> Bool {
     if lhs.v != rhs.v {return false}
@@ -39591,12 +40275,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.value: Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.value != 0 {
-      try visitor.visitSingularInt32Field(value: self.value, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.value }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.value) -> Bool {
     if lhs.value != rhs.value {return false}
@@ -39623,12 +40305,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.valueField:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.valueField != 0 {
-      try visitor.visitSingularInt32Field(value: self.valueField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.valueField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.valueField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.valueField) -> Bool {
     if lhs.valueField != rhs.valueField {return false}
@@ -39655,12 +40335,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.values: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.values != 0 {
-      try visitor.visitSingularInt32Field(value: self.values, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.values }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.values, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.values) -> Bool {
     if lhs.values != rhs.values {return false}
@@ -39687,12 +40365,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ValueType:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.valueType != 0 {
-      try visitor.visitSingularInt32Field(value: self.valueType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.valueType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ValueType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ValueType) -> Bool {
     if lhs.valueType != rhs.valueType {return false}
@@ -39719,12 +40395,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.varMessage:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`var` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`var`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`var` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.varMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.varMessage) -> Bool {
     if lhs.`var` != rhs.`var` {return false}
@@ -39751,12 +40425,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.verificatio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.verification != 0 {
-      try visitor.visitSingularInt32Field(value: self.verification, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.verification }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.verification, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.verification) -> Bool {
     if lhs.verification != rhs.verification {return false}
@@ -39783,12 +40455,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Verificatio
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.verificationState != 0 {
-      try visitor.visitSingularInt32Field(value: self.verificationState, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.verificationState }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VerificationState, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VerificationState) -> Bool {
     if lhs.verificationState != rhs.verificationState {return false}
@@ -39815,12 +40485,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Version: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.version != 0 {
-      try visitor.visitSingularInt32Field(value: self.version, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.version }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Version, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Version) -> Bool {
     if lhs.version != rhs.version {return false}
@@ -39847,12 +40515,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.versionStri
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.versionString != 0 {
-      try visitor.visitSingularInt32Field(value: self.versionString, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.versionString }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.versionString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.versionString) -> Bool {
     if lhs.versionString != rhs.versionString {return false}
@@ -39879,12 +40545,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtens
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitExtensionFields != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitExtensionFields, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitExtensionFields }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFields) -> Bool {
     if lhs.visitExtensionFields != rhs.visitExtensionFields {return false}
@@ -39911,12 +40575,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtens
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitExtensionFieldsAsMessageSet != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitExtensionFieldsAsMessageSet, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitExtensionFieldsAsMessageSet }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet) -> Bool {
     if lhs.visitExtensionFieldsAsMessageSet != rhs.visitExtensionFieldsAsMessageSet {return false}
@@ -39943,12 +40605,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitMapFie
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitMapField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitMapField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitMapField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitMapField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitMapField) -> Bool {
     if lhs.visitMapField != rhs.visitMapField {return false}
@@ -39975,12 +40635,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitor: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitor != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitor, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitor }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitor) -> Bool {
     if lhs.visitor != rhs.visitor {return false}
@@ -40007,12 +40665,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPacked != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPacked, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPacked }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked) -> Bool {
     if lhs.visitPacked != rhs.visitPacked {return false}
@@ -40039,12 +40695,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedBoolField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedBoolField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedBoolField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedBoolField) -> Bool {
     if lhs.visitPackedBoolField != rhs.visitPackedBoolField {return false}
@@ -40071,12 +40725,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedDoubleField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedDoubleField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedDoubleField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedDoubleField) -> Bool {
     if lhs.visitPackedDoubleField != rhs.visitPackedDoubleField {return false}
@@ -40103,12 +40755,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedEnumField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedEnumField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedEnumField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedEnumField) -> Bool {
     if lhs.visitPackedEnumField != rhs.visitPackedEnumField {return false}
@@ -40135,12 +40785,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedFixed32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedFixed32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedFixed32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed32Field) -> Bool {
     if lhs.visitPackedFixed32Field != rhs.visitPackedFixed32Field {return false}
@@ -40167,12 +40815,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedFixed64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedFixed64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedFixed64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed64Field) -> Bool {
     if lhs.visitPackedFixed64Field != rhs.visitPackedFixed64Field {return false}
@@ -40199,12 +40845,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedFloatField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedFloatField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedFloatField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFloatField) -> Bool {
     if lhs.visitPackedFloatField != rhs.visitPackedFloatField {return false}
@@ -40231,12 +40875,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedInt32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedInt32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedInt32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt32Field) -> Bool {
     if lhs.visitPackedInt32Field != rhs.visitPackedInt32Field {return false}
@@ -40263,12 +40905,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedInt64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedInt64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedInt64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt64Field) -> Bool {
     if lhs.visitPackedInt64Field != rhs.visitPackedInt64Field {return false}
@@ -40295,12 +40935,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedSfixed32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedSfixed32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedSfixed32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field) -> Bool {
     if lhs.visitPackedSfixed32Field != rhs.visitPackedSfixed32Field {return false}
@@ -40327,12 +40965,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedSfixed64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedSfixed64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedSfixed64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field) -> Bool {
     if lhs.visitPackedSfixed64Field != rhs.visitPackedSfixed64Field {return false}
@@ -40359,12 +40995,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedSint32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedSint32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedSint32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt32Field) -> Bool {
     if lhs.visitPackedSint32Field != rhs.visitPackedSint32Field {return false}
@@ -40391,12 +41025,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedSint64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedSint64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedSint64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt64Field) -> Bool {
     if lhs.visitPackedSint64Field != rhs.visitPackedSint64Field {return false}
@@ -40423,12 +41055,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedUint32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedUint32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedUint32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt32Field) -> Bool {
     if lhs.visitPackedUint32Field != rhs.visitPackedUint32Field {return false}
@@ -40455,12 +41085,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitPackedUint64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitPackedUint64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitPackedUint64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt64Field) -> Bool {
     if lhs.visitPackedUint64Field != rhs.visitPackedUint64Field {return false}
@@ -40487,12 +41115,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeated != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeated, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeated }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeated) -> Bool {
     if lhs.visitRepeated != rhs.visitRepeated {return false}
@@ -40519,12 +41145,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedBoolField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedBoolField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedBoolField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBoolField) -> Bool {
     if lhs.visitRepeatedBoolField != rhs.visitRepeatedBoolField {return false}
@@ -40551,12 +41175,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedBytesField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedBytesField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedBytesField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBytesField) -> Bool {
     if lhs.visitRepeatedBytesField != rhs.visitRepeatedBytesField {return false}
@@ -40583,12 +41205,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedDoubleField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedDoubleField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedDoubleField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField) -> Bool {
     if lhs.visitRepeatedDoubleField != rhs.visitRepeatedDoubleField {return false}
@@ -40615,12 +41235,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedEnumField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedEnumField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedEnumField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedEnumField) -> Bool {
     if lhs.visitRepeatedEnumField != rhs.visitRepeatedEnumField {return false}
@@ -40647,12 +41265,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedFixed32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedFixed32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedFixed32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field) -> Bool {
     if lhs.visitRepeatedFixed32Field != rhs.visitRepeatedFixed32Field {return false}
@@ -40679,12 +41295,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedFixed64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedFixed64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedFixed64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field) -> Bool {
     if lhs.visitRepeatedFixed64Field != rhs.visitRepeatedFixed64Field {return false}
@@ -40711,12 +41325,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedFloatField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedFloatField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedFloatField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFloatField) -> Bool {
     if lhs.visitRepeatedFloatField != rhs.visitRepeatedFloatField {return false}
@@ -40743,12 +41355,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedGroupField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedGroupField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedGroupField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedGroupField) -> Bool {
     if lhs.visitRepeatedGroupField != rhs.visitRepeatedGroupField {return false}
@@ -40775,12 +41385,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedInt32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedInt32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedInt32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field) -> Bool {
     if lhs.visitRepeatedInt32Field != rhs.visitRepeatedInt32Field {return false}
@@ -40807,12 +41415,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedInt64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedInt64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedInt64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field) -> Bool {
     if lhs.visitRepeatedInt64Field != rhs.visitRepeatedInt64Field {return false}
@@ -40839,12 +41445,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedMessageField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedMessageField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedMessageField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedMessageField) -> Bool {
     if lhs.visitRepeatedMessageField != rhs.visitRepeatedMessageField {return false}
@@ -40871,12 +41475,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedSfixed32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedSfixed32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedSfixed32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field) -> Bool {
     if lhs.visitRepeatedSfixed32Field != rhs.visitRepeatedSfixed32Field {return false}
@@ -40903,12 +41505,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedSfixed64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedSfixed64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedSfixed64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field) -> Bool {
     if lhs.visitRepeatedSfixed64Field != rhs.visitRepeatedSfixed64Field {return false}
@@ -40935,12 +41535,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedSint32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedSint32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedSint32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field) -> Bool {
     if lhs.visitRepeatedSint32Field != rhs.visitRepeatedSint32Field {return false}
@@ -40967,12 +41565,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedSint64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedSint64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedSint64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field) -> Bool {
     if lhs.visitRepeatedSint64Field != rhs.visitRepeatedSint64Field {return false}
@@ -40999,12 +41595,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedStringField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedStringField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedStringField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedStringField) -> Bool {
     if lhs.visitRepeatedStringField != rhs.visitRepeatedStringField {return false}
@@ -41031,12 +41625,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedUint32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedUint32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedUint32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field) -> Bool {
     if lhs.visitRepeatedUint32Field != rhs.visitRepeatedUint32Field {return false}
@@ -41063,12 +41655,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeat
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitRepeatedUint64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitRepeatedUint64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitRepeatedUint64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field) -> Bool {
     if lhs.visitRepeatedUint64Field != rhs.visitRepeatedUint64Field {return false}
@@ -41095,12 +41685,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingular != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingular, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingular }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingular, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingular) -> Bool {
     if lhs.visitSingular != rhs.visitSingular {return false}
@@ -41127,12 +41715,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularBoolField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularBoolField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularBoolField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBoolField) -> Bool {
     if lhs.visitSingularBoolField != rhs.visitSingularBoolField {return false}
@@ -41159,12 +41745,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularBytesField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularBytesField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularBytesField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBytesField) -> Bool {
     if lhs.visitSingularBytesField != rhs.visitSingularBytesField {return false}
@@ -41191,12 +41775,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularDoubleField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularDoubleField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularDoubleField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularDoubleField) -> Bool {
     if lhs.visitSingularDoubleField != rhs.visitSingularDoubleField {return false}
@@ -41223,12 +41805,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularEnumField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularEnumField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularEnumField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularEnumField) -> Bool {
     if lhs.visitSingularEnumField != rhs.visitSingularEnumField {return false}
@@ -41255,12 +41835,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularFixed32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularFixed32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularFixed32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed32Field) -> Bool {
     if lhs.visitSingularFixed32Field != rhs.visitSingularFixed32Field {return false}
@@ -41287,12 +41865,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularFixed64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularFixed64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularFixed64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed64Field) -> Bool {
     if lhs.visitSingularFixed64Field != rhs.visitSingularFixed64Field {return false}
@@ -41319,12 +41895,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularFloatField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularFloatField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularFloatField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFloatField) -> Bool {
     if lhs.visitSingularFloatField != rhs.visitSingularFloatField {return false}
@@ -41351,12 +41925,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularGroupField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularGroupField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularGroupField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularGroupField) -> Bool {
     if lhs.visitSingularGroupField != rhs.visitSingularGroupField {return false}
@@ -41383,12 +41955,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularInt32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularInt32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularInt32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt32Field) -> Bool {
     if lhs.visitSingularInt32Field != rhs.visitSingularInt32Field {return false}
@@ -41415,12 +41985,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularInt64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularInt64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularInt64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt64Field) -> Bool {
     if lhs.visitSingularInt64Field != rhs.visitSingularInt64Field {return false}
@@ -41447,12 +42015,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularMessageField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularMessageField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularMessageField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularMessageField) -> Bool {
     if lhs.visitSingularMessageField != rhs.visitSingularMessageField {return false}
@@ -41479,12 +42045,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularSfixed32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularSfixed32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularSfixed32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field) -> Bool {
     if lhs.visitSingularSfixed32Field != rhs.visitSingularSfixed32Field {return false}
@@ -41511,12 +42075,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularSfixed64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularSfixed64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularSfixed64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field) -> Bool {
     if lhs.visitSingularSfixed64Field != rhs.visitSingularSfixed64Field {return false}
@@ -41543,12 +42105,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularSint32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularSint32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularSint32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt32Field) -> Bool {
     if lhs.visitSingularSint32Field != rhs.visitSingularSint32Field {return false}
@@ -41575,12 +42135,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularSint64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularSint64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularSint64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt64Field) -> Bool {
     if lhs.visitSingularSint64Field != rhs.visitSingularSint64Field {return false}
@@ -41607,12 +42165,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularStringField != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularStringField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularStringField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularStringField) -> Bool {
     if lhs.visitSingularStringField != rhs.visitSingularStringField {return false}
@@ -41639,12 +42195,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularUint32Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularUint32Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularUint32Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt32Field) -> Bool {
     if lhs.visitSingularUint32Field != rhs.visitSingularUint32Field {return false}
@@ -41671,12 +42225,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingul
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitSingularUint64Field != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitSingularUint64Field, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitSingularUint64Field }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt64Field) -> Bool {
     if lhs.visitSingularUint64Field != rhs.visitSingularUint64Field {return false}
@@ -41703,12 +42255,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitUnknow
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.visitUnknown != 0 {
-      try visitor.visitSingularInt32Field(value: self.visitUnknown, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.visitUnknown }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitUnknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitUnknown) -> Bool {
     if lhs.visitUnknown != rhs.visitUnknown {return false}
@@ -41735,12 +42285,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wasDecoded:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.wasDecoded != 0 {
-      try visitor.visitSingularInt32Field(value: self.wasDecoded, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.wasDecoded }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wasDecoded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wasDecoded) -> Bool {
     if lhs.wasDecoded != rhs.wasDecoded {return false}
@@ -41767,12 +42315,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weak: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.weak != 0 {
-      try visitor.visitSingularInt32Field(value: self.weak, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.weak }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weak, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weak) -> Bool {
     if lhs.weak != rhs.weak {return false}
@@ -41799,12 +42345,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weakDepende
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.weakDependency != 0 {
-      try visitor.visitSingularInt32Field(value: self.weakDependency, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.weakDependency }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weakDependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weakDependency) -> Bool {
     if lhs.weakDependency != rhs.weakDependency {return false}
@@ -41831,12 +42375,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.whereMessag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.`where` != 0 {
-      try visitor.visitSingularInt32Field(value: self.`where`, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`where` }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.whereMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.whereMessage) -> Bool {
     if lhs.`where` != rhs.`where` {return false}
@@ -41863,12 +42405,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wireFormat:
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.wireFormat != 0 {
-      try visitor.visitSingularInt32Field(value: self.wireFormat, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.wireFormat }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wireFormat) -> Bool {
     if lhs.wireFormat != rhs.wireFormat {return false}
@@ -41895,12 +42435,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.with: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.with != 0 {
-      try visitor.visitSingularInt32Field(value: self.with, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.with }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.with, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.with) -> Bool {
     if lhs.with != rhs.with {return false}
@@ -41927,12 +42465,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeB
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.withUnsafeBytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.withUnsafeBytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.withUnsafeBytes }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeBytes) -> Bool {
     if lhs.withUnsafeBytes != rhs.withUnsafeBytes {return false}
@@ -41959,12 +42495,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeM
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.withUnsafeMutableBytes != 0 {
-      try visitor.visitSingularInt32Field(value: self.withUnsafeMutableBytes, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.withUnsafeMutableBytes }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes) -> Bool {
     if lhs.withUnsafeMutableBytes != rhs.withUnsafeMutableBytes {return false}
@@ -41991,12 +42525,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.work: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.work != 0 {
-      try visitor.visitSingularInt32Field(value: self.work, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.work }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.work, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.work) -> Bool {
     if lhs.work != rhs.work {return false}
@@ -42023,12 +42555,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Wrapped: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.wrapped != 0 {
-      try visitor.visitSingularInt32Field(value: self.wrapped, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.wrapped }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Wrapped, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Wrapped) -> Bool {
     if lhs.wrapped != rhs.wrapped {return false}
@@ -42055,12 +42585,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.WrappedType
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.wrappedType != 0 {
-      try visitor.visitSingularInt32Field(value: self.wrappedType, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.wrappedType }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.WrappedType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.WrappedType) -> Bool {
     if lhs.wrappedType != rhs.wrappedType {return false}
@@ -42087,12 +42615,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wrappedValu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.wrappedValue != 0 {
-      try visitor.visitSingularInt32Field(value: self.wrappedValue, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.wrappedValue }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wrappedValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wrappedValue) -> Bool {
     if lhs.wrappedValue != rhs.wrappedValue {return false}
@@ -42119,12 +42645,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.written: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.written != 0 {
-      try visitor.visitSingularInt32Field(value: self.written, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.written }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.written, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.written) -> Bool {
     if lhs.written != rhs.written {return false}
@@ -42151,12 +42675,10 @@ extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.yday: Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.yday != 0 {
-      try visitor.visitSingularInt32Field(value: self.yday, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.yday }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.yday, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.yday) -> Bool {
     if lhs.yday != rhs.yday {return false}
diff --git a/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift b/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift
index 1164cb190..c47773ded 100644
--- a/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift
+++ b/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift
@@ -254,51 +254,23 @@ extension SwiftProtoTesting_TestEnumMap: SwiftProtobuf.Message, SwiftProtobuf._M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.knownMapField.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnum>.self, value: self.knownMapField, fieldNumber: 101)
-    }
-    if !self.unknownMapField.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapField, fieldNumber: 102)
-    }
-    if !self.unknownMapFieldInt64.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldInt64, fieldNumber: 200)
-    }
-    if !self.unknownMapFieldUint64.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldUint64, fieldNumber: 201)
-    }
-    if !self.unknownMapFieldInt32.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldInt32, fieldNumber: 202)
-    }
-    if !self.unknownMapFieldUint32.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldUint32, fieldNumber: 203)
-    }
-    if !self.unknownMapFieldFixed32.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldFixed32, fieldNumber: 204)
-    }
-    if !self.unknownMapFieldFixed64.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldFixed64, fieldNumber: 205)
-    }
-    if !self.unknownMapFieldBool.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldBool, fieldNumber: 206)
-    }
-    if !self.unknownMapFieldString.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldString, fieldNumber: 207)
-    }
-    if !self.unknownMapFieldSint32.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldSint32, fieldNumber: 208)
-    }
-    if !self.unknownMapFieldSint64.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldSint64, fieldNumber: 209)
-    }
-    if !self.unknownMapFieldSfixed32.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldSfixed32, fieldNumber: 210)
-    }
-    if !self.unknownMapFieldSfixed64.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Proto2MapEnum>.self, value: self.unknownMapFieldSfixed64, fieldNumber: 211)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnum>.self, { $0.knownMapField }, fieldNumber: 101),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapField }, fieldNumber: 102),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldInt64 }, fieldNumber: 200),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldUint64 }, fieldNumber: 201),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldInt32 }, fieldNumber: 202),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldUint32 }, fieldNumber: 203),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldFixed32 }, fieldNumber: 204),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldFixed64 }, fieldNumber: 205),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldBool }, fieldNumber: 206),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldString }, fieldNumber: 207),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldSint32 }, fieldNumber: 208),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldSint64 }, fieldNumber: 209),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldSfixed32 }, fieldNumber: 210),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Proto2MapEnum>.self, { $0.unknownMapFieldSfixed64 }, fieldNumber: 211),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestEnumMap, rhs: SwiftProtoTesting_TestEnumMap) -> Bool {
     if lhs.knownMapField != rhs.knownMapField {return false}
@@ -364,51 +336,23 @@ extension SwiftProtoTesting_TestEnumMapPlusExtra: SwiftProtobuf.Message, SwiftPr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.knownMapField.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.knownMapField, fieldNumber: 101)
-    }
-    if !self.unknownMapField.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapField, fieldNumber: 102)
-    }
-    if !self.unknownMapFieldInt64.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldInt64, fieldNumber: 200)
-    }
-    if !self.unknownMapFieldUint64.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldUint64, fieldNumber: 201)
-    }
-    if !self.unknownMapFieldInt32.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldInt32, fieldNumber: 202)
-    }
-    if !self.unknownMapFieldUint32.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldUint32, fieldNumber: 203)
-    }
-    if !self.unknownMapFieldFixed32.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldFixed32, fieldNumber: 204)
-    }
-    if !self.unknownMapFieldFixed64.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldFixed64, fieldNumber: 205)
-    }
-    if !self.unknownMapFieldBool.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldBool, fieldNumber: 206)
-    }
-    if !self.unknownMapFieldString.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldString, fieldNumber: 207)
-    }
-    if !self.unknownMapFieldSint32.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldSint32, fieldNumber: 208)
-    }
-    if !self.unknownMapFieldSint64.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldSint64, fieldNumber: 209)
-    }
-    if !self.unknownMapFieldSfixed32.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldSfixed32, fieldNumber: 210)
-    }
-    if !self.unknownMapFieldSfixed64.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, value: self.unknownMapFieldSfixed64, fieldNumber: 211)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.knownMapField }, fieldNumber: 101),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapField }, fieldNumber: 102),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldInt64 }, fieldNumber: 200),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldUint64 }, fieldNumber: 201),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldInt32 }, fieldNumber: 202),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldUint32 }, fieldNumber: 203),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldFixed32 }, fieldNumber: 204),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldFixed64 }, fieldNumber: 205),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldBool }, fieldNumber: 206),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldString }, fieldNumber: 207),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldSint32 }, fieldNumber: 208),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldSint64 }, fieldNumber: 209),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldSfixed32 }, fieldNumber: 210),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Proto2MapEnumPlusExtra>.self, { $0.unknownMapFieldSfixed64 }, fieldNumber: 211),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestEnumMapPlusExtra, rhs: SwiftProtoTesting_TestEnumMapPlusExtra) -> Bool {
     if lhs.knownMapField != rhs.knownMapField {return false}
diff --git a/Tests/SwiftProtobufTests/map_unittest.pb.swift b/Tests/SwiftProtobufTests/map_unittest.pb.swift
index f1728bc32..f2e259dbf 100644
--- a/Tests/SwiftProtobufTests/map_unittest.pb.swift
+++ b/Tests/SwiftProtobufTests/map_unittest.pb.swift
@@ -345,68 +345,28 @@ extension SwiftProtoTesting_TestMap: SwiftProtobuf.Message, SwiftProtobuf._Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      if !_storage._mapInt32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapInt32Int32, fieldNumber: 1)
-      }
-      if !_storage._mapInt64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapInt64Int64, fieldNumber: 2)
-      }
-      if !_storage._mapUint32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapUint32Uint32, fieldNumber: 3)
-      }
-      if !_storage._mapUint64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapUint64Uint64, fieldNumber: 4)
-      }
-      if !_storage._mapSint32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSint32Sint32, fieldNumber: 5)
-      }
-      if !_storage._mapSint64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSint64Sint64, fieldNumber: 6)
-      }
-      if !_storage._mapFixed32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapFixed32Fixed32, fieldNumber: 7)
-      }
-      if !_storage._mapFixed64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapFixed64Fixed64, fieldNumber: 8)
-      }
-      if !_storage._mapSfixed32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 9)
-      }
-      if !_storage._mapSfixed64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 10)
-      }
-      if !_storage._mapInt32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapInt32Float, fieldNumber: 11)
-      }
-      if !_storage._mapInt32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapInt32Double, fieldNumber: 12)
-      }
-      if !_storage._mapBoolBool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapBoolBool, fieldNumber: 13)
-      }
-      if !_storage._mapStringString.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, value: _storage._mapStringString, fieldNumber: 14)
-      }
-      if !_storage._mapInt32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapInt32Bytes, fieldNumber: 15)
-      }
-      if !_storage._mapInt32Enum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_MapEnum>.self, value: _storage._mapInt32Enum, fieldNumber: 16)
-      }
-      if !_storage._mapInt32ForeignMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_ForeignMessage>.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17)
-      }
-      if !_storage._mapStringForeignMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_ForeignMessage>.self, value: _storage._mapStringForeignMessage, fieldNumber: 18)
-      }
-      if !_storage._mapInt32AllTypes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_TestAllTypes>.self, value: _storage._mapInt32AllTypes, fieldNumber: 19)
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 1),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 2),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 3),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 4),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 5),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 6),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 7),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 8),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 9),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 10),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 11),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 12),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 13),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 14),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt32Bytes }, fieldNumber: 15),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_MapEnum>.self, { $0.mapInt32Enum }, fieldNumber: 16),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_ForeignMessage>.self, { $0.mapInt32ForeignMessage }, fieldNumber: 17),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_ForeignMessage>.self, { $0.mapStringForeignMessage }, fieldNumber: 18),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_TestAllTypes>.self, { $0.mapInt32AllTypes }, fieldNumber: 19),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestMap, rhs: SwiftProtoTesting_TestMap) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -464,12 +424,10 @@ extension SwiftProtoTesting_TestRequiredMessageMap: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.mapField.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_TestRequired>.self, value: self.mapField, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_TestRequired>.self, { $0.mapField }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestRequiredMessageMap, rhs: SwiftProtoTesting_TestRequiredMessageMap) -> Bool {
     if lhs.mapField != rhs.mapField {return false}
@@ -496,12 +454,10 @@ extension SwiftProtoTesting_TestRecursiveMapMessage: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.a.isEmpty {
-      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_TestRecursiveMapMessage>.self, value: self.a, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_TestRecursiveMapMessage>.self, { $0.a }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestRecursiveMapMessage, rhs: SwiftProtoTesting_TestRecursiveMapMessage) -> Bool {
     if lhs.a != rhs.a {return false}
diff --git a/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift b/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift
index 23f15c768..75520cdd6 100644
--- a/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift
+++ b/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift
@@ -1354,361 +1354,144 @@ extension SwiftProtoTesting_Test3_TestAllTypesProto3: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      if _storage._optionalInt32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1)
-      }
-      if _storage._optionalInt64 != 0 {
-        try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2)
-      }
-      if _storage._optionalUint32 != 0 {
-        try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3)
-      }
-      if _storage._optionalUint64 != 0 {
-        try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4)
-      }
-      if _storage._optionalSint32 != 0 {
-        try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5)
-      }
-      if _storage._optionalSint64 != 0 {
-        try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6)
-      }
-      if _storage._optionalFixed32 != 0 {
-        try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7)
-      }
-      if _storage._optionalFixed64 != 0 {
-        try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8)
-      }
-      if _storage._optionalSfixed32 != 0 {
-        try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9)
-      }
-      if _storage._optionalSfixed64 != 0 {
-        try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10)
-      }
-      if _storage._optionalFloat != 0 {
-        try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11)
-      }
-      if _storage._optionalDouble != 0 {
-        try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12)
-      }
-      if _storage._optionalBool != false {
-        try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13)
-      }
-      if !_storage._optionalString.isEmpty {
-        try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14)
-      }
-      if !_storage._optionalBytes.isEmpty {
-        try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15)
-      }
-      try { if let v = _storage._optionalNestedMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      if _storage._optionalNestedEnum != .foo {
-        try visitor.visitSingularEnumField(value: _storage._optionalNestedEnum, fieldNumber: 21)
-      }
-      if !_storage._repeatedInt32.isEmpty {
-        try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31)
-      }
-      if !_storage._repeatedInt64.isEmpty {
-        try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32)
-      }
-      if !_storage._repeatedUint32.isEmpty {
-        try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33)
-      }
-      if !_storage._repeatedUint64.isEmpty {
-        try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34)
-      }
-      if !_storage._repeatedSint32.isEmpty {
-        try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35)
-      }
-      if !_storage._repeatedSint64.isEmpty {
-        try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36)
-      }
-      if !_storage._repeatedFixed32.isEmpty {
-        try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37)
-      }
-      if !_storage._repeatedFixed64.isEmpty {
-        try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38)
-      }
-      if !_storage._repeatedSfixed32.isEmpty {
-        try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39)
-      }
-      if !_storage._repeatedSfixed64.isEmpty {
-        try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40)
-      }
-      if !_storage._repeatedFloat.isEmpty {
-        try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41)
-      }
-      if !_storage._repeatedDouble.isEmpty {
-        try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42)
-      }
-      if !_storage._repeatedBool.isEmpty {
-        try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43)
-      }
-      if !_storage._repeatedString.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44)
-      }
-      if !_storage._repeatedBytes.isEmpty {
-        try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45)
-      }
-      if !_storage._repeatedNestedMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48)
-      }
-      if !_storage._repeatedNestedEnum.isEmpty {
-        try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51)
-      }
-      if !_storage._mapInt32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapInt32Int32, fieldNumber: 56)
-      }
-      if !_storage._mapInt64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapInt64Int64, fieldNumber: 57)
-      }
-      if !_storage._mapUint32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapUint32Uint32, fieldNumber: 58)
-      }
-      if !_storage._mapUint64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapUint64Uint64, fieldNumber: 59)
-      }
-      if !_storage._mapSint32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSint32Sint32, fieldNumber: 60)
-      }
-      if !_storage._mapSint64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSint64Sint64, fieldNumber: 61)
-      }
-      if !_storage._mapFixed32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62)
-      }
-      if !_storage._mapFixed64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63)
-      }
-      if !_storage._mapSfixed32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64)
-      }
-      if !_storage._mapSfixed64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65)
-      }
-      if !_storage._mapInt32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapInt32Float, fieldNumber: 66)
-      }
-      if !_storage._mapInt32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapInt32Double, fieldNumber: 67)
-      }
-      if !_storage._mapBoolBool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapBoolBool, fieldNumber: 68)
-      }
-      if !_storage._mapStringString.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, value: _storage._mapStringString, fieldNumber: 69)
-      }
-      if !_storage._mapStringBytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapStringBytes, fieldNumber: 70)
-      }
-      if !_storage._mapStringNestedMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage>.self, value: _storage._mapStringNestedMessage, fieldNumber: 71)
-      }
-      if !_storage._mapStringNestedEnum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum>.self, value: _storage._mapStringNestedEnum, fieldNumber: 73)
-      }
-      switch _storage._oneofField {
-      case .oneofUint32?: try {
-        guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111)
-      }()
-      case .oneofNestedMessage?: try {
-        guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 112)
-      }()
-      case .oneofString?: try {
-        guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularStringField(value: v, fieldNumber: 113)
-      }()
-      case .oneofBytes?: try {
-        guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 114)
-      }()
-      case .oneofBool?: try {
-        guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 115)
-      }()
-      case .oneofUint64?: try {
-        guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116)
-      }()
-      case .oneofFloat?: try {
-        guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 117)
-      }()
-      case .oneofDouble?: try {
-        guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 118)
-      }()
-      case .oneofEnum?: try {
-        guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 119)
-      }()
-      case .oneofNullValue?: try {
-        guard case .oneofNullValue(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 120)
-      }()
-      case nil: break
-      }
-      try { if let v = _storage._optionalBoolWrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 201)
-      } }()
-      try { if let v = _storage._optionalInt32Wrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 202)
-      } }()
-      try { if let v = _storage._optionalInt64Wrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 203)
-      } }()
-      try { if let v = _storage._optionalUint32Wrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 204)
-      } }()
-      try { if let v = _storage._optionalUint64Wrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 205)
-      } }()
-      try { if let v = _storage._optionalFloatWrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 206)
-      } }()
-      try { if let v = _storage._optionalDoubleWrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 207)
-      } }()
-      try { if let v = _storage._optionalStringWrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 208)
-      } }()
-      try { if let v = _storage._optionalBytesWrapper {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 209)
-      } }()
-      if !_storage._repeatedBoolWrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedBoolWrapper, fieldNumber: 211)
-      }
-      if !_storage._repeatedInt32Wrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedInt32Wrapper, fieldNumber: 212)
-      }
-      if !_storage._repeatedInt64Wrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedInt64Wrapper, fieldNumber: 213)
-      }
-      if !_storage._repeatedUint32Wrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedUint32Wrapper, fieldNumber: 214)
-      }
-      if !_storage._repeatedUint64Wrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedUint64Wrapper, fieldNumber: 215)
-      }
-      if !_storage._repeatedFloatWrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedFloatWrapper, fieldNumber: 216)
-      }
-      if !_storage._repeatedDoubleWrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedDoubleWrapper, fieldNumber: 217)
-      }
-      if !_storage._repeatedStringWrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedStringWrapper, fieldNumber: 218)
-      }
-      if !_storage._repeatedBytesWrapper.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedBytesWrapper, fieldNumber: 219)
-      }
-      try { if let v = _storage._optionalDuration {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 301)
-      } }()
-      try { if let v = _storage._optionalTimestamp {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 302)
-      } }()
-      try { if let v = _storage._optionalFieldMask {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 303)
-      } }()
-      try { if let v = _storage._optionalStruct {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 304)
-      } }()
-      try { if let v = _storage._optionalAny {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 305)
-      } }()
-      try { if let v = _storage._optionalValue {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 306)
-      } }()
-      if _storage._optionalNullValue != .nullValue {
-        try visitor.visitSingularEnumField(value: _storage._optionalNullValue, fieldNumber: 307)
-      }
-      if !_storage._repeatedDuration.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedDuration, fieldNumber: 311)
-      }
-      if !_storage._repeatedTimestamp.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedTimestamp, fieldNumber: 312)
-      }
-      if !_storage._repeatedFieldmask.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedFieldmask, fieldNumber: 313)
-      }
-      if !_storage._repeatedAny.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedAny, fieldNumber: 315)
-      }
-      if !_storage._repeatedValue.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedValue, fieldNumber: 316)
-      }
-      if !_storage._repeatedListValue.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedListValue, fieldNumber: 317)
-      }
-      if !_storage._repeatedStruct.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedStruct, fieldNumber: 324)
-      }
-      if _storage._fieldname1 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldname1, fieldNumber: 401)
-      }
-      if _storage._fieldName2 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName2, fieldNumber: 402)
-      }
-      if _storage._fieldName3 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName3, fieldNumber: 403)
-      }
-      if _storage._field_Name4_ != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field_Name4_, fieldNumber: 404)
-      }
-      if _storage._field0Name5 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field0Name5, fieldNumber: 405)
-      }
-      if _storage._field0Name6 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field0Name6, fieldNumber: 406)
-      }
-      if _storage._fieldName7 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName7, fieldNumber: 407)
-      }
-      if _storage._fieldName8 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName8, fieldNumber: 408)
-      }
-      if _storage._fieldName9 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName9, fieldNumber: 409)
-      }
-      if _storage._fieldName10 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName10, fieldNumber: 410)
-      }
-      if _storage._fieldName11 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName11, fieldNumber: 411)
-      }
-      if _storage._fieldName12 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName12, fieldNumber: 412)
-      }
-      if _storage.__FieldName13 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage.__FieldName13, fieldNumber: 413)
-      }
-      if _storage.__FieldName14 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage.__FieldName14, fieldNumber: 414)
-      }
-      if _storage._field_Name15 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field_Name15, fieldNumber: 415)
-      }
-      if _storage._field_Name16 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._field_Name16, fieldNumber: 416)
-      }
-      if _storage._fieldName17__ != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName17__, fieldNumber: 417)
-      }
-      if _storage._fieldName18__ != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._fieldName18__, fieldNumber: 418)
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalInt32 }, fieldNumber: 1),
+    .singularInt64({ $0.optionalInt64 }, fieldNumber: 2),
+    .singularUInt32({ $0.optionalUint32 }, fieldNumber: 3),
+    .singularUInt64({ $0.optionalUint64 }, fieldNumber: 4),
+    .singularSInt32({ $0.optionalSint32 }, fieldNumber: 5),
+    .singularSInt64({ $0.optionalSint64 }, fieldNumber: 6),
+    .singularFixed32({ $0.optionalFixed32 }, fieldNumber: 7),
+    .singularFixed64({ $0.optionalFixed64 }, fieldNumber: 8),
+    .singularSFixed32({ $0.optionalSfixed32 }, fieldNumber: 9),
+    .singularSFixed64({ $0.optionalSfixed64 }, fieldNumber: 10),
+    .singularFloat({ $0.optionalFloat }, fieldNumber: 11),
+    .singularDouble({ $0.optionalDouble }, fieldNumber: 12),
+    .singularBool({ $0.optionalBool }, fieldNumber: 13),
+    .singularString({ $0.optionalString }, fieldNumber: 14),
+    .singularBytes({ $0.optionalBytes }, fieldNumber: 15),
+    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
+    .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, defaultValue: .foo),
+    .packedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
+    .packedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
+    .packedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
+    .packedUInt64({ $0.repeatedUint64 }, fieldNumber: 34),
+    .packedSInt32({ $0.repeatedSint32 }, fieldNumber: 35),
+    .packedSInt64({ $0.repeatedSint64 }, fieldNumber: 36),
+    .packedFixed32({ $0.repeatedFixed32 }, fieldNumber: 37),
+    .packedFixed64({ $0.repeatedFixed64 }, fieldNumber: 38),
+    .packedSFixed32({ $0.repeatedSfixed32 }, fieldNumber: 39),
+    .packedSFixed64({ $0.repeatedSfixed64 }, fieldNumber: 40),
+    .packedFloat({ $0.repeatedFloat }, fieldNumber: 41),
+    .packedDouble({ $0.repeatedDouble }, fieldNumber: 42),
+    .packedBool({ $0.repeatedBool }, fieldNumber: 43),
+    .repeatedString({ $0.repeatedString }, fieldNumber: 44),
+    .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
+    .repeatedMessage({ $0.repeatedNestedMessage }, fieldNumber: 48),
+    .packedEnum({ $0.repeatedNestedEnum }, fieldNumber: 51),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 56),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 57),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 58),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 59),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 60),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 61),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 62),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 63),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 64),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 65),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 66),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 67),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 68),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 69),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0.mapStringBytes }, fieldNumber: 70),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage>.self, { $0.mapStringNestedMessage }, fieldNumber: 71),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum>.self, { $0.mapStringNestedEnum }, fieldNumber: 73),
+    .oneOf({ $0.oneofField }) {
+      switch $0 {
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofNestedMessage:
+        return _oneOfField_oneofNestedMessage
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
+      case .oneofBool:
+        return _oneOfField_oneofBool
+      case .oneofUint64:
+        return _oneOfField_oneofUint64
+      case .oneofFloat:
+        return _oneOfField_oneofFloat
+      case .oneofDouble:
+        return _oneOfField_oneofDouble
+      case .oneofEnum:
+        return _oneOfField_oneofEnum
+      case .oneofNullValue:
+        return _oneOfField_oneofNullValue
+      }
+    },
+    .singularMessage({ $0.optionalBoolWrapper }, fieldNumber: 201, isUnset: { $0._storage._optionalBoolWrapper == nil }),
+    .singularMessage({ $0.optionalInt32Wrapper }, fieldNumber: 202, isUnset: { $0._storage._optionalInt32Wrapper == nil }),
+    .singularMessage({ $0.optionalInt64Wrapper }, fieldNumber: 203, isUnset: { $0._storage._optionalInt64Wrapper == nil }),
+    .singularMessage({ $0.optionalUint32Wrapper }, fieldNumber: 204, isUnset: { $0._storage._optionalUint32Wrapper == nil }),
+    .singularMessage({ $0.optionalUint64Wrapper }, fieldNumber: 205, isUnset: { $0._storage._optionalUint64Wrapper == nil }),
+    .singularMessage({ $0.optionalFloatWrapper }, fieldNumber: 206, isUnset: { $0._storage._optionalFloatWrapper == nil }),
+    .singularMessage({ $0.optionalDoubleWrapper }, fieldNumber: 207, isUnset: { $0._storage._optionalDoubleWrapper == nil }),
+    .singularMessage({ $0.optionalStringWrapper }, fieldNumber: 208, isUnset: { $0._storage._optionalStringWrapper == nil }),
+    .singularMessage({ $0.optionalBytesWrapper }, fieldNumber: 209, isUnset: { $0._storage._optionalBytesWrapper == nil }),
+    .repeatedMessage({ $0.repeatedBoolWrapper }, fieldNumber: 211),
+    .repeatedMessage({ $0.repeatedInt32Wrapper }, fieldNumber: 212),
+    .repeatedMessage({ $0.repeatedInt64Wrapper }, fieldNumber: 213),
+    .repeatedMessage({ $0.repeatedUint32Wrapper }, fieldNumber: 214),
+    .repeatedMessage({ $0.repeatedUint64Wrapper }, fieldNumber: 215),
+    .repeatedMessage({ $0.repeatedFloatWrapper }, fieldNumber: 216),
+    .repeatedMessage({ $0.repeatedDoubleWrapper }, fieldNumber: 217),
+    .repeatedMessage({ $0.repeatedStringWrapper }, fieldNumber: 218),
+    .repeatedMessage({ $0.repeatedBytesWrapper }, fieldNumber: 219),
+    .singularMessage({ $0.optionalDuration }, fieldNumber: 301, isUnset: { $0._storage._optionalDuration == nil }),
+    .singularMessage({ $0.optionalTimestamp }, fieldNumber: 302, isUnset: { $0._storage._optionalTimestamp == nil }),
+    .singularMessage({ $0.optionalFieldMask }, fieldNumber: 303, isUnset: { $0._storage._optionalFieldMask == nil }),
+    .singularMessage({ $0.optionalStruct }, fieldNumber: 304, isUnset: { $0._storage._optionalStruct == nil }),
+    .singularMessage({ $0.optionalAny }, fieldNumber: 305, isUnset: { $0._storage._optionalAny == nil }),
+    .singularMessage({ $0.optionalValue }, fieldNumber: 306, isUnset: { $0._storage._optionalValue == nil }),
+    .singularEnum({ $0.optionalNullValue }, fieldNumber: 307, defaultValue: .nullValue),
+    .repeatedMessage({ $0.repeatedDuration }, fieldNumber: 311),
+    .repeatedMessage({ $0.repeatedTimestamp }, fieldNumber: 312),
+    .repeatedMessage({ $0.repeatedFieldmask }, fieldNumber: 313),
+    .repeatedMessage({ $0.repeatedAny }, fieldNumber: 315),
+    .repeatedMessage({ $0.repeatedValue }, fieldNumber: 316),
+    .repeatedMessage({ $0.repeatedListValue }, fieldNumber: 317),
+    .repeatedMessage({ $0.repeatedStruct }, fieldNumber: 324),
+    .singularInt32({ $0.fieldname1 }, fieldNumber: 401),
+    .singularInt32({ $0.fieldName2 }, fieldNumber: 402),
+    .singularInt32({ $0.fieldName3 }, fieldNumber: 403),
+    .singularInt32({ $0.field_Name4_ }, fieldNumber: 404),
+    .singularInt32({ $0.field0Name5 }, fieldNumber: 405),
+    .singularInt32({ $0.field0Name6 }, fieldNumber: 406),
+    .singularInt32({ $0.fieldName7 }, fieldNumber: 407),
+    .singularInt32({ $0.fieldName8 }, fieldNumber: 408),
+    .singularInt32({ $0.fieldName9 }, fieldNumber: 409),
+    .singularInt32({ $0.fieldName10 }, fieldNumber: 410),
+    .singularInt32({ $0.fieldName11 }, fieldNumber: 411),
+    .singularInt32({ $0.fieldName12 }, fieldNumber: 412),
+    .singularInt32({ $0._FieldName13 }, fieldNumber: 413),
+    .singularInt32({ $0._FieldName14 }, fieldNumber: 414),
+    .singularInt32({ $0.field_Name15 }, fieldNumber: 415),
+    .singularInt32({ $0.field_Name16 }, fieldNumber: 416),
+    .singularInt32({ $0.fieldName17__ }, fieldNumber: 417),
+    .singularInt32({ $0.fieldName18__ }, fieldNumber: 418),
+  ]
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
+  private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 115, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint64: Field<Self> = .singularUInt64({ $0.oneofUint64 }, fieldNumber: 116, isUnset: { _ in false })
+  private static let _oneOfField_oneofFloat: Field<Self> = .singularFloat({ $0.oneofFloat }, fieldNumber: 117, isUnset: { _ in false })
+  private static let _oneOfField_oneofDouble: Field<Self> = .singularDouble({ $0.oneofDouble }, fieldNumber: 118, isUnset: { _ in false })
+  private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 119, isUnset: { _ in false })
+  private static let _oneOfField_oneofNullValue: Field<Self> = .singularEnum({ $0.oneofNullValue }, fieldNumber: 120, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Test3_TestAllTypesProto3, rhs: SwiftProtoTesting_Test3_TestAllTypesProto3) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -1879,21 +1662,11 @@ extension SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage: SwiftProtobu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      if _storage._a != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._a, fieldNumber: 1)
-      }
-      try { if let v = _storage._corecursive {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1),
+    .singularMessage({ $0.corecursive }, fieldNumber: 2, isUnset: { $0._storage._corecursive == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage, rhs: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage) -> Bool {
     if lhs._storage !== rhs._storage {
diff --git a/Tests/SwiftProtobufTests/unittest.pb.swift b/Tests/SwiftProtobufTests/unittest.pb.swift
index 28c5d01de..fde89aa10 100644
--- a/Tests/SwiftProtobufTests/unittest.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest.pb.swift
@@ -4339,250 +4339,97 @@ extension SwiftProtoTesting_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._optionalInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._optionalInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._optionalUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._optionalUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._optionalSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._optionalSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._optionalFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._optionalFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._optionalSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._optionalSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._optionalFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._optionalDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._optionalBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._optionalString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._optionalBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._optionalGroup {
-        try visitor.visitSingularGroupField(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._optionalNestedMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._optionalForeignMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 19)
-      } }()
-      try { if let v = _storage._optionalImportMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 20)
-      } }()
-      try { if let v = _storage._optionalNestedEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 21)
-      } }()
-      try { if let v = _storage._optionalForeignEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 22)
-      } }()
-      try { if let v = _storage._optionalImportEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 23)
-      } }()
-      try { if let v = _storage._optionalStringPiece {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 24)
-      } }()
-      try { if let v = _storage._optionalCord {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 25)
-      } }()
-      try { if let v = _storage._optionalPublicImportMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 26)
-      } }()
-      try { if let v = _storage._optionalLazyMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 27)
-      } }()
-      try { if let v = _storage._optionalUnverifiedLazyMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 28)
-      } }()
-      if !_storage._repeatedInt32.isEmpty {
-        try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31)
-      }
-      if !_storage._repeatedInt64.isEmpty {
-        try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32)
-      }
-      if !_storage._repeatedUint32.isEmpty {
-        try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33)
-      }
-      if !_storage._repeatedUint64.isEmpty {
-        try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34)
-      }
-      if !_storage._repeatedSint32.isEmpty {
-        try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35)
-      }
-      if !_storage._repeatedSint64.isEmpty {
-        try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36)
-      }
-      if !_storage._repeatedFixed32.isEmpty {
-        try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37)
-      }
-      if !_storage._repeatedFixed64.isEmpty {
-        try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38)
-      }
-      if !_storage._repeatedSfixed32.isEmpty {
-        try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39)
-      }
-      if !_storage._repeatedSfixed64.isEmpty {
-        try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40)
-      }
-      if !_storage._repeatedFloat.isEmpty {
-        try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41)
-      }
-      if !_storage._repeatedDouble.isEmpty {
-        try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42)
-      }
-      if !_storage._repeatedBool.isEmpty {
-        try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43)
-      }
-      if !_storage._repeatedString.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44)
-      }
-      if !_storage._repeatedBytes.isEmpty {
-        try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45)
-      }
-      if !_storage._repeatedGroup.isEmpty {
-        try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46)
-      }
-      if !_storage._repeatedNestedMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48)
-      }
-      if !_storage._repeatedForeignMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49)
-      }
-      if !_storage._repeatedImportMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50)
-      }
-      if !_storage._repeatedNestedEnum.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51)
-      }
-      if !_storage._repeatedForeignEnum.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52)
-      }
-      if !_storage._repeatedImportEnum.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._repeatedImportEnum, fieldNumber: 53)
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalInt32 }, fieldNumber: 1, isUnset: { $0._storage._optionalInt32 == nil }),
+    .singularInt64({ $0.optionalInt64 }, fieldNumber: 2, isUnset: { $0._storage._optionalInt64 == nil }),
+    .singularUInt32({ $0.optionalUint32 }, fieldNumber: 3, isUnset: { $0._storage._optionalUint32 == nil }),
+    .singularUInt64({ $0.optionalUint64 }, fieldNumber: 4, isUnset: { $0._storage._optionalUint64 == nil }),
+    .singularSInt32({ $0.optionalSint32 }, fieldNumber: 5, isUnset: { $0._storage._optionalSint32 == nil }),
+    .singularSInt64({ $0.optionalSint64 }, fieldNumber: 6, isUnset: { $0._storage._optionalSint64 == nil }),
+    .singularFixed32({ $0.optionalFixed32 }, fieldNumber: 7, isUnset: { $0._storage._optionalFixed32 == nil }),
+    .singularFixed64({ $0.optionalFixed64 }, fieldNumber: 8, isUnset: { $0._storage._optionalFixed64 == nil }),
+    .singularSFixed32({ $0.optionalSfixed32 }, fieldNumber: 9, isUnset: { $0._storage._optionalSfixed32 == nil }),
+    .singularSFixed64({ $0.optionalSfixed64 }, fieldNumber: 10, isUnset: { $0._storage._optionalSfixed64 == nil }),
+    .singularFloat({ $0.optionalFloat }, fieldNumber: 11, isUnset: { $0._storage._optionalFloat == nil }),
+    .singularDouble({ $0.optionalDouble }, fieldNumber: 12, isUnset: { $0._storage._optionalDouble == nil }),
+    .singularBool({ $0.optionalBool }, fieldNumber: 13, isUnset: { $0._storage._optionalBool == nil }),
+    .singularString({ $0.optionalString }, fieldNumber: 14, isUnset: { $0._storage._optionalString == nil }),
+    .singularBytes({ $0.optionalBytes }, fieldNumber: 15, isUnset: { $0._storage._optionalBytes == nil }),
+    .singularGroup({ $0.optionalGroup }, fieldNumber: 16, isUnset: { $0._storage._optionalGroup == nil }),
+    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
+    .singularMessage({ $0.optionalForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._optionalForeignMessage == nil }),
+    .singularMessage({ $0.optionalImportMessage }, fieldNumber: 20, isUnset: { $0._storage._optionalImportMessage == nil }),
+    .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, isUnset: { $0._storage._optionalNestedEnum == nil }),
+    .singularEnum({ $0.optionalForeignEnum }, fieldNumber: 22, isUnset: { $0._storage._optionalForeignEnum == nil }),
+    .singularEnum({ $0.optionalImportEnum }, fieldNumber: 23, isUnset: { $0._storage._optionalImportEnum == nil }),
+    .singularString({ $0.optionalStringPiece }, fieldNumber: 24, isUnset: { $0._storage._optionalStringPiece == nil }),
+    .singularString({ $0.optionalCord }, fieldNumber: 25, isUnset: { $0._storage._optionalCord == nil }),
+    .singularMessage({ $0.optionalPublicImportMessage }, fieldNumber: 26, isUnset: { $0._storage._optionalPublicImportMessage == nil }),
+    .singularMessage({ $0.optionalLazyMessage }, fieldNumber: 27, isUnset: { $0._storage._optionalLazyMessage == nil }),
+    .singularMessage({ $0.optionalUnverifiedLazyMessage }, fieldNumber: 28, isUnset: { $0._storage._optionalUnverifiedLazyMessage == nil }),
+    .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
+    .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
+    .repeatedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
+    .repeatedUInt64({ $0.repeatedUint64 }, fieldNumber: 34),
+    .repeatedSInt32({ $0.repeatedSint32 }, fieldNumber: 35),
+    .repeatedSInt64({ $0.repeatedSint64 }, fieldNumber: 36),
+    .repeatedFixed32({ $0.repeatedFixed32 }, fieldNumber: 37),
+    .repeatedFixed64({ $0.repeatedFixed64 }, fieldNumber: 38),
+    .repeatedSFixed32({ $0.repeatedSfixed32 }, fieldNumber: 39),
+    .repeatedSFixed64({ $0.repeatedSfixed64 }, fieldNumber: 40),
+    .repeatedFloat({ $0.repeatedFloat }, fieldNumber: 41),
+    .repeatedDouble({ $0.repeatedDouble }, fieldNumber: 42),
+    .repeatedBool({ $0.repeatedBool }, fieldNumber: 43),
+    .repeatedString({ $0.repeatedString }, fieldNumber: 44),
+    .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
+    .repeatedGroup({ $0.repeatedGroup }, fieldNumber: 46),
+    .repeatedMessage({ $0.repeatedNestedMessage }, fieldNumber: 48),
+    .repeatedMessage({ $0.repeatedForeignMessage }, fieldNumber: 49),
+    .repeatedMessage({ $0.repeatedImportMessage }, fieldNumber: 50),
+    .repeatedEnum({ $0.repeatedNestedEnum }, fieldNumber: 51),
+    .repeatedEnum({ $0.repeatedForeignEnum }, fieldNumber: 52),
+    .repeatedEnum({ $0.repeatedImportEnum }, fieldNumber: 53),
+    .repeatedString({ $0.repeatedStringPiece }, fieldNumber: 54),
+    .repeatedString({ $0.repeatedCord }, fieldNumber: 55),
+    .repeatedMessage({ $0.repeatedLazyMessage }, fieldNumber: 57),
+    .singularInt32({ $0.defaultInt32 }, fieldNumber: 61, isUnset: { $0._storage._defaultInt32 == nil }),
+    .singularInt64({ $0.defaultInt64 }, fieldNumber: 62, isUnset: { $0._storage._defaultInt64 == nil }),
+    .singularUInt32({ $0.defaultUint32 }, fieldNumber: 63, isUnset: { $0._storage._defaultUint32 == nil }),
+    .singularUInt64({ $0.defaultUint64 }, fieldNumber: 64, isUnset: { $0._storage._defaultUint64 == nil }),
+    .singularSInt32({ $0.defaultSint32 }, fieldNumber: 65, isUnset: { $0._storage._defaultSint32 == nil }),
+    .singularSInt64({ $0.defaultSint64 }, fieldNumber: 66, isUnset: { $0._storage._defaultSint64 == nil }),
+    .singularFixed32({ $0.defaultFixed32 }, fieldNumber: 67, isUnset: { $0._storage._defaultFixed32 == nil }),
+    .singularFixed64({ $0.defaultFixed64 }, fieldNumber: 68, isUnset: { $0._storage._defaultFixed64 == nil }),
+    .singularSFixed32({ $0.defaultSfixed32 }, fieldNumber: 69, isUnset: { $0._storage._defaultSfixed32 == nil }),
+    .singularSFixed64({ $0.defaultSfixed64 }, fieldNumber: 70, isUnset: { $0._storage._defaultSfixed64 == nil }),
+    .singularFloat({ $0.defaultFloat }, fieldNumber: 71, isUnset: { $0._storage._defaultFloat == nil }),
+    .singularDouble({ $0.defaultDouble }, fieldNumber: 72, isUnset: { $0._storage._defaultDouble == nil }),
+    .singularBool({ $0.defaultBool }, fieldNumber: 73, isUnset: { $0._storage._defaultBool == nil }),
+    .singularString({ $0.defaultString }, fieldNumber: 74, isUnset: { $0._storage._defaultString == nil }),
+    .singularBytes({ $0.defaultBytes }, fieldNumber: 75, isUnset: { $0._storage._defaultBytes == nil }),
+    .singularEnum({ $0.defaultNestedEnum }, fieldNumber: 81, isUnset: { $0._storage._defaultNestedEnum == nil }),
+    .singularEnum({ $0.defaultForeignEnum }, fieldNumber: 82, isUnset: { $0._storage._defaultForeignEnum == nil }),
+    .singularEnum({ $0.defaultImportEnum }, fieldNumber: 83, isUnset: { $0._storage._defaultImportEnum == nil }),
+    .singularString({ $0.defaultStringPiece }, fieldNumber: 84, isUnset: { $0._storage._defaultStringPiece == nil }),
+    .singularString({ $0.defaultCord }, fieldNumber: 85, isUnset: { $0._storage._defaultCord == nil }),
+    .oneOf({ $0.oneofField }) {
+      switch $0 {
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofNestedMessage:
+        return _oneOfField_oneofNestedMessage
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
       }
-      if !_storage._repeatedStringPiece.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54)
-      }
-      if !_storage._repeatedCord.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55)
-      }
-      if !_storage._repeatedLazyMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57)
-      }
-      try { if let v = _storage._defaultInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 61)
-      } }()
-      try { if let v = _storage._defaultInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 62)
-      } }()
-      try { if let v = _storage._defaultUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63)
-      } }()
-      try { if let v = _storage._defaultUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64)
-      } }()
-      try { if let v = _storage._defaultSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65)
-      } }()
-      try { if let v = _storage._defaultSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66)
-      } }()
-      try { if let v = _storage._defaultFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67)
-      } }()
-      try { if let v = _storage._defaultFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68)
-      } }()
-      try { if let v = _storage._defaultSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69)
-      } }()
-      try { if let v = _storage._defaultSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70)
-      } }()
-      try { if let v = _storage._defaultFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 71)
-      } }()
-      try { if let v = _storage._defaultDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 72)
-      } }()
-      try { if let v = _storage._defaultBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 73)
-      } }()
-      try { if let v = _storage._defaultString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 74)
-      } }()
-      try { if let v = _storage._defaultBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 75)
-      } }()
-      try { if let v = _storage._defaultNestedEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 81)
-      } }()
-      try { if let v = _storage._defaultForeignEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 82)
-      } }()
-      try { if let v = _storage._defaultImportEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 83)
-      } }()
-      try { if let v = _storage._defaultStringPiece {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 84)
-      } }()
-      try { if let v = _storage._defaultCord {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 85)
-      } }()
-      switch _storage._oneofField {
-      case .oneofUint32?: try {
-        guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111)
-      }()
-      case .oneofNestedMessage?: try {
-        guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 112)
-      }()
-      case .oneofString?: try {
-        guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularStringField(value: v, fieldNumber: 113)
-      }()
-      case .oneofBytes?: try {
-        guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 114)
-      }()
-      case nil: break
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+    },
+  ]
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_TestAllTypes, rhs: SwiftProtoTesting_TestAllTypes) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -4698,16 +4545,10 @@ extension SwiftProtoTesting_TestAllTypes.NestedMessage: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._bb {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bb }, fieldNumber: 1, isUnset: { $0._bb == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestAllTypes.NestedMessage, rhs: SwiftProtoTesting_TestAllTypes.NestedMessage) -> Bool {
     if lhs._bb != rhs._bb {return false}
@@ -4734,16 +4575,10 @@ extension SwiftProtoTesting_TestAllTypes.OptionalGroup: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 17)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 17, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestAllTypes.OptionalGroup, rhs: SwiftProtoTesting_TestAllTypes.OptionalGroup) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -4770,16 +4605,10 @@ extension SwiftProtoTesting_TestAllTypes.RepeatedGroup: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 47)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 47, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestAllTypes.RepeatedGroup, rhs: SwiftProtoTesting_TestAllTypes.RepeatedGroup) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -4844,30 +4673,14 @@ extension SwiftProtoTesting_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._child {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._payload {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-      if !_storage._repeatedChild.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedChild, fieldNumber: 3)
-      }
-      try { if let v = _storage._lazyChild {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._eagerChild {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.child }, fieldNumber: 1, isUnset: { $0._storage._child == nil }),
+    .singularMessage({ $0.payload }, fieldNumber: 2, isUnset: { $0._storage._payload == nil }),
+    .repeatedMessage({ $0.repeatedChild }, fieldNumber: 3),
+    .singularMessage({ $0.lazyChild }, fieldNumber: 4, isUnset: { $0._storage._lazyChild == nil }),
+    .singularMessage({ $0.eagerChild }, fieldNumber: 5, isUnset: { $0._storage._eagerChild == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_NestedTestAllTypes, rhs: SwiftProtoTesting_NestedTestAllTypes) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -4908,19 +4721,11 @@ extension SwiftProtoTesting_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._c {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._d {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.c }, fieldNumber: 1, isUnset: { $0._c == nil }),
+    .singularInt32({ $0.d }, fieldNumber: 2, isUnset: { $0._d == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_ForeignMessage, rhs: SwiftProtoTesting_ForeignMessage) -> Bool {
     if lhs._c != rhs._c {return false}
@@ -4947,10 +4752,10 @@ extension SwiftProtoTesting_TestAllExtensions: SwiftProtobuf.Message, SwiftProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1, end: 536870912),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestAllExtensions, rhs: SwiftProtoTesting_TestAllExtensions) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -4977,16 +4782,10 @@ extension SwiftProtoTesting_OptionalGroup_extension: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 17)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 17, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_OptionalGroup_extension, rhs: SwiftProtoTesting_OptionalGroup_extension) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -5013,16 +4812,10 @@ extension SwiftProtoTesting_RepeatedGroup_extension: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 47)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 47, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_RepeatedGroup_extension, rhs: SwiftProtoTesting_RepeatedGroup_extension) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -5040,9 +4833,9 @@ extension SwiftProtoTesting_TestNestedExtension: SwiftProtobuf.Message, SwiftPro
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestNestedExtension, rhs: SwiftProtoTesting_TestNestedExtension) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -5231,117 +5024,43 @@ extension SwiftProtoTesting_TestRequired: SwiftProtobuf.Message, SwiftProtobuf._
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._a {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._dummy2 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._b {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._dummy4 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._dummy5 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._dummy6 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._dummy7 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._dummy8 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._dummy9 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._dummy10 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._dummy11 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._dummy12 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._dummy13 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._dummy14 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._dummy15 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._dummy16 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._dummy17 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 17)
-      } }()
-      try { if let v = _storage._dummy18 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._dummy19 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 19)
-      } }()
-      try { if let v = _storage._dummy20 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 20)
-      } }()
-      try { if let v = _storage._dummy21 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 21)
-      } }()
-      try { if let v = _storage._dummy22 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 22)
-      } }()
-      try { if let v = _storage._dummy23 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 23)
-      } }()
-      try { if let v = _storage._dummy24 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 24)
-      } }()
-      try { if let v = _storage._dummy25 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 25)
-      } }()
-      try { if let v = _storage._dummy26 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 26)
-      } }()
-      try { if let v = _storage._dummy27 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 27)
-      } }()
-      try { if let v = _storage._dummy28 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 28)
-      } }()
-      try { if let v = _storage._dummy29 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 29)
-      } }()
-      try { if let v = _storage._dummy30 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 30)
-      } }()
-      try { if let v = _storage._dummy31 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 31)
-      } }()
-      try { if let v = _storage._dummy32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 32)
-      } }()
-      try { if let v = _storage._c {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 33)
-      } }()
-      try { if let v = _storage._optionalForeign {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 34)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._storage._a == nil }),
+    .singularInt32({ $0.dummy2 }, fieldNumber: 2, isUnset: { $0._storage._dummy2 == nil }),
+    .singularInt32({ $0.b }, fieldNumber: 3, isUnset: { $0._storage._b == nil }),
+    .singularInt32({ $0.dummy4 }, fieldNumber: 4, isUnset: { $0._storage._dummy4 == nil }),
+    .singularInt32({ $0.dummy5 }, fieldNumber: 5, isUnset: { $0._storage._dummy5 == nil }),
+    .singularInt32({ $0.dummy6 }, fieldNumber: 6, isUnset: { $0._storage._dummy6 == nil }),
+    .singularInt32({ $0.dummy7 }, fieldNumber: 7, isUnset: { $0._storage._dummy7 == nil }),
+    .singularInt32({ $0.dummy8 }, fieldNumber: 8, isUnset: { $0._storage._dummy8 == nil }),
+    .singularInt32({ $0.dummy9 }, fieldNumber: 9, isUnset: { $0._storage._dummy9 == nil }),
+    .singularInt32({ $0.dummy10 }, fieldNumber: 10, isUnset: { $0._storage._dummy10 == nil }),
+    .singularInt32({ $0.dummy11 }, fieldNumber: 11, isUnset: { $0._storage._dummy11 == nil }),
+    .singularInt32({ $0.dummy12 }, fieldNumber: 12, isUnset: { $0._storage._dummy12 == nil }),
+    .singularInt32({ $0.dummy13 }, fieldNumber: 13, isUnset: { $0._storage._dummy13 == nil }),
+    .singularInt32({ $0.dummy14 }, fieldNumber: 14, isUnset: { $0._storage._dummy14 == nil }),
+    .singularInt32({ $0.dummy15 }, fieldNumber: 15, isUnset: { $0._storage._dummy15 == nil }),
+    .singularInt32({ $0.dummy16 }, fieldNumber: 16, isUnset: { $0._storage._dummy16 == nil }),
+    .singularInt32({ $0.dummy17 }, fieldNumber: 17, isUnset: { $0._storage._dummy17 == nil }),
+    .singularInt32({ $0.dummy18 }, fieldNumber: 18, isUnset: { $0._storage._dummy18 == nil }),
+    .singularInt32({ $0.dummy19 }, fieldNumber: 19, isUnset: { $0._storage._dummy19 == nil }),
+    .singularInt32({ $0.dummy20 }, fieldNumber: 20, isUnset: { $0._storage._dummy20 == nil }),
+    .singularInt32({ $0.dummy21 }, fieldNumber: 21, isUnset: { $0._storage._dummy21 == nil }),
+    .singularInt32({ $0.dummy22 }, fieldNumber: 22, isUnset: { $0._storage._dummy22 == nil }),
+    .singularInt32({ $0.dummy23 }, fieldNumber: 23, isUnset: { $0._storage._dummy23 == nil }),
+    .singularInt32({ $0.dummy24 }, fieldNumber: 24, isUnset: { $0._storage._dummy24 == nil }),
+    .singularInt32({ $0.dummy25 }, fieldNumber: 25, isUnset: { $0._storage._dummy25 == nil }),
+    .singularInt32({ $0.dummy26 }, fieldNumber: 26, isUnset: { $0._storage._dummy26 == nil }),
+    .singularInt32({ $0.dummy27 }, fieldNumber: 27, isUnset: { $0._storage._dummy27 == nil }),
+    .singularInt32({ $0.dummy28 }, fieldNumber: 28, isUnset: { $0._storage._dummy28 == nil }),
+    .singularInt32({ $0.dummy29 }, fieldNumber: 29, isUnset: { $0._storage._dummy29 == nil }),
+    .singularInt32({ $0.dummy30 }, fieldNumber: 30, isUnset: { $0._storage._dummy30 == nil }),
+    .singularInt32({ $0.dummy31 }, fieldNumber: 31, isUnset: { $0._storage._dummy31 == nil }),
+    .singularInt32({ $0.dummy32 }, fieldNumber: 32, isUnset: { $0._storage._dummy32 == nil }),
+    .singularInt32({ $0.c }, fieldNumber: 33, isUnset: { $0._storage._c == nil }),
+    .singularMessage({ $0.optionalForeign }, fieldNumber: 34, isUnset: { $0._storage._optionalForeign == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestRequired, rhs: SwiftProtoTesting_TestRequired) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -5421,25 +5140,13 @@ extension SwiftProtoTesting_TestRequiredForeign: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._optionalMessage {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    } }()
-    if !self.repeatedMessage.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2)
-    }
-    try { if let v = self._dummy {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._optionalLazyMessage {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.optionalMessage }, fieldNumber: 1, isUnset: { $0._optionalMessage == nil }),
+    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 2),
+    .singularInt32({ $0.dummy }, fieldNumber: 3, isUnset: { $0._dummy == nil }),
+    .singularMessage({ $0.optionalLazyMessage }, fieldNumber: 4, isUnset: { $0._optionalLazyMessage == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestRequiredForeign, rhs: SwiftProtoTesting_TestRequiredForeign) -> Bool {
     if lhs._optionalMessage != rhs._optionalMessage {return false}
@@ -5481,22 +5188,12 @@ extension SwiftProtoTesting_TestRequiredMessage: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._optionalMessage {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    } }()
-    if !self.repeatedMessage.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2)
-    }
-    try { if let v = self._requiredMessage {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.optionalMessage }, fieldNumber: 1, isUnset: { $0._optionalMessage == nil }),
+    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 2),
+    .singularMessage({ $0.requiredMessage }, fieldNumber: 3, isUnset: { $0._requiredMessage == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestRequiredMessage, rhs: SwiftProtoTesting_TestRequiredMessage) -> Bool {
     if lhs._optionalMessage != rhs._optionalMessage {return false}
@@ -5516,9 +5213,9 @@ extension SwiftProtoTesting_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtob
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestEmptyMessage, rhs: SwiftProtoTesting_TestEmptyMessage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -5546,19 +5243,11 @@ extension SwiftProtoTesting_TestReallyLargeTagNumber: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._bb {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 268435455)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._a == nil }),
+    .singularInt32({ $0.bb }, fieldNumber: 268435455, isUnset: { $0._bb == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestReallyLargeTagNumber, rhs: SwiftProtoTesting_TestReallyLargeTagNumber) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -5612,21 +5301,11 @@ extension SwiftProtoTesting_TestRecursiveMessage: SwiftProtobuf.Message, SwiftPr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._a {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._i {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.a }, fieldNumber: 1, isUnset: { $0._storage._a == nil }),
+    .singularInt32({ $0.i }, fieldNumber: 2, isUnset: { $0._storage._i == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestRecursiveMessage, rhs: SwiftProtoTesting_TestRecursiveMessage) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -5675,27 +5354,15 @@ extension SwiftProtoTesting_TestFieldOrderings: SwiftProtobuf.Message, SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._myInt {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 1)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 11)
-    try { if let v = self._myString {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 11)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 12, end: 101)
-    try { if let v = self._myFloat {
-      try visitor.visitSingularFloatField(value: v, fieldNumber: 101)
-    } }()
-    try { if let v = self._optionalNestedMessage {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 200)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.myInt }, fieldNumber: 1, isUnset: { $0._myInt == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 2, end: 11),
+    .singularString({ $0.myString }, fieldNumber: 11, isUnset: { $0._myString == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 12, end: 101),
+    .singularFloat({ $0.myFloat }, fieldNumber: 101, isUnset: { $0._myFloat == nil }),
+    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 200, isUnset: { $0._optionalNestedMessage == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestFieldOrderings, rhs: SwiftProtoTesting_TestFieldOrderings) -> Bool {
     if lhs._myString != rhs._myString {return false}
@@ -5728,19 +5395,11 @@ extension SwiftProtoTesting_TestFieldOrderings.NestedMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._bb {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._oo {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bb }, fieldNumber: 1, isUnset: { $0._bb == nil }),
+    .singularInt64({ $0.oo }, fieldNumber: 2, isUnset: { $0._oo == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestFieldOrderings.NestedMessage, rhs: SwiftProtoTesting_TestFieldOrderings.NestedMessage) -> Bool {
     if lhs._oo != rhs._oo {return false}
@@ -5894,96 +5553,36 @@ extension SwiftProtoTesting_TestExtremeDefaultValues: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._escapedBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._largeUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._largeUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._smallInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._smallInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._utf8String {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._zeroFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._oneFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._smallFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._negativeOneFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._negativeFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._largeFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._smallNegativeFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._infDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._negInfDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._nanDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._infFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 17)
-      } }()
-      try { if let v = _storage._negInfFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._nanFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 19)
-      } }()
-      try { if let v = _storage._cppTrigraph {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 20)
-      } }()
-      try { if let v = _storage._reallySmallInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 21)
-      } }()
-      try { if let v = _storage._reallySmallInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 22)
-      } }()
-      try { if let v = _storage._stringWithZero {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 23)
-      } }()
-      try { if let v = _storage._bytesWithZero {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 24)
-      } }()
-      try { if let v = _storage._stringPieceWithZero {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 25)
-      } }()
-      try { if let v = _storage._cordWithZero {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 26)
-      } }()
-      try { if let v = _storage._replacementString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 27)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularBytes({ $0.escapedBytes }, fieldNumber: 1, isUnset: { $0._storage._escapedBytes == nil }),
+    .singularUInt32({ $0.largeUint32 }, fieldNumber: 2, isUnset: { $0._storage._largeUint32 == nil }),
+    .singularUInt64({ $0.largeUint64 }, fieldNumber: 3, isUnset: { $0._storage._largeUint64 == nil }),
+    .singularInt32({ $0.smallInt32 }, fieldNumber: 4, isUnset: { $0._storage._smallInt32 == nil }),
+    .singularInt64({ $0.smallInt64 }, fieldNumber: 5, isUnset: { $0._storage._smallInt64 == nil }),
+    .singularString({ $0.utf8String }, fieldNumber: 6, isUnset: { $0._storage._utf8String == nil }),
+    .singularFloat({ $0.zeroFloat }, fieldNumber: 7, isUnset: { $0._storage._zeroFloat == nil }),
+    .singularFloat({ $0.oneFloat }, fieldNumber: 8, isUnset: { $0._storage._oneFloat == nil }),
+    .singularFloat({ $0.smallFloat }, fieldNumber: 9, isUnset: { $0._storage._smallFloat == nil }),
+    .singularFloat({ $0.negativeOneFloat }, fieldNumber: 10, isUnset: { $0._storage._negativeOneFloat == nil }),
+    .singularFloat({ $0.negativeFloat }, fieldNumber: 11, isUnset: { $0._storage._negativeFloat == nil }),
+    .singularFloat({ $0.largeFloat }, fieldNumber: 12, isUnset: { $0._storage._largeFloat == nil }),
+    .singularFloat({ $0.smallNegativeFloat }, fieldNumber: 13, isUnset: { $0._storage._smallNegativeFloat == nil }),
+    .singularDouble({ $0.infDouble }, fieldNumber: 14, isUnset: { $0._storage._infDouble == nil }),
+    .singularDouble({ $0.negInfDouble }, fieldNumber: 15, isUnset: { $0._storage._negInfDouble == nil }),
+    .singularDouble({ $0.nanDouble }, fieldNumber: 16, isUnset: { $0._storage._nanDouble == nil }),
+    .singularFloat({ $0.infFloat }, fieldNumber: 17, isUnset: { $0._storage._infFloat == nil }),
+    .singularFloat({ $0.negInfFloat }, fieldNumber: 18, isUnset: { $0._storage._negInfFloat == nil }),
+    .singularFloat({ $0.nanFloat }, fieldNumber: 19, isUnset: { $0._storage._nanFloat == nil }),
+    .singularString({ $0.cppTrigraph }, fieldNumber: 20, isUnset: { $0._storage._cppTrigraph == nil }),
+    .singularInt32({ $0.reallySmallInt32 }, fieldNumber: 21, isUnset: { $0._storage._reallySmallInt32 == nil }),
+    .singularInt64({ $0.reallySmallInt64 }, fieldNumber: 22, isUnset: { $0._storage._reallySmallInt64 == nil }),
+    .singularString({ $0.stringWithZero }, fieldNumber: 23, isUnset: { $0._storage._stringWithZero == nil }),
+    .singularBytes({ $0.bytesWithZero }, fieldNumber: 24, isUnset: { $0._storage._bytesWithZero == nil }),
+    .singularString({ $0.stringPieceWithZero }, fieldNumber: 25, isUnset: { $0._storage._stringPieceWithZero == nil }),
+    .singularString({ $0.cordWithZero }, fieldNumber: 26, isUnset: { $0._storage._cordWithZero == nil }),
+    .singularString({ $0.replacementString }, fieldNumber: 27, isUnset: { $0._storage._replacementString == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestExtremeDefaultValues, rhs: SwiftProtoTesting_TestExtremeDefaultValues) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -6088,32 +5687,25 @@ extension SwiftProtoTesting_TestOneof: SwiftProtobuf.Message, SwiftProtobuf._Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    switch self.foo {
-    case .fooInt?: try {
-      guard case .fooInt(let v)? = self.foo else { preconditionFailure() }
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    }()
-    case .fooString?: try {
-      guard case .fooString(let v)? = self.foo else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    }()
-    case .fooMessage?: try {
-      guard case .fooMessage(let v)? = self.foo else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    }()
-    case .fooGroup?: try {
-      guard case .fooGroup(let v)? = self.foo else { preconditionFailure() }
-      try visitor.visitSingularGroupField(value: v, fieldNumber: 4)
-    }()
-    case nil: break
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .oneOf({ $0.foo }) {
+      switch $0 {
+      case .fooInt:
+        return _oneOfField_fooInt
+      case .fooString:
+        return _oneOfField_fooString
+      case .fooMessage:
+        return _oneOfField_fooMessage
+      case .fooGroup:
+        return _oneOfField_fooGroup
+      }
+    },
+  ]
+  private static let _oneOfField_fooInt: Field<Self> = .singularInt32({ $0.fooInt }, fieldNumber: 1, isUnset: { _ in false })
+  private static let _oneOfField_fooString: Field<Self> = .singularString({ $0.fooString }, fieldNumber: 2, isUnset: { _ in false })
+  private static let _oneOfField_fooMessage: Field<Self> = .singularMessage({ $0.fooMessage }, fieldNumber: 3, isUnset: { _ in false })
+  private static let _oneOfField_fooGroup: Field<Self> = .singularGroup({ $0.fooGroup }, fieldNumber: 4, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_TestOneof, rhs: SwiftProtoTesting_TestOneof) -> Bool {
     if lhs.foo != rhs.foo {return false}
@@ -6142,19 +5734,11 @@ extension SwiftProtoTesting_TestOneof.FooGroup: SwiftProtobuf.Message, SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 5)
-    } }()
-    try { if let v = self._b {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 6)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 5, isUnset: { $0._a == nil }),
+    .singularString({ $0.b }, fieldNumber: 6, isUnset: { $0._b == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestOneof.FooGroup, rhs: SwiftProtoTesting_TestOneof.FooGroup) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -6231,32 +5815,25 @@ extension SwiftProtoTesting_TestRequiredOneof: SwiftProtobuf.Message, SwiftProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    switch self.foo {
-    case .fooInt?: try {
-      guard case .fooInt(let v)? = self.foo else { preconditionFailure() }
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    }()
-    case .fooString?: try {
-      guard case .fooString(let v)? = self.foo else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
-    }()
-    case .fooMessage?: try {
-      guard case .fooMessage(let v)? = self.foo else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    }()
-    case .fooLazyMessage?: try {
-      guard case .fooLazyMessage(let v)? = self.foo else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
-    }()
-    case nil: break
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .oneOf({ $0.foo }) {
+      switch $0 {
+      case .fooInt:
+        return _oneOfField_fooInt
+      case .fooString:
+        return _oneOfField_fooString
+      case .fooMessage:
+        return _oneOfField_fooMessage
+      case .fooLazyMessage:
+        return _oneOfField_fooLazyMessage
+      }
+    },
+  ]
+  private static let _oneOfField_fooInt: Field<Self> = .singularInt32({ $0.fooInt }, fieldNumber: 1, isUnset: { _ in false })
+  private static let _oneOfField_fooString: Field<Self> = .singularString({ $0.fooString }, fieldNumber: 2, isUnset: { _ in false })
+  private static let _oneOfField_fooMessage: Field<Self> = .singularMessage({ $0.fooMessage }, fieldNumber: 3, isUnset: { _ in false })
+  private static let _oneOfField_fooLazyMessage: Field<Self> = .singularMessage({ $0.fooLazyMessage }, fieldNumber: 4, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_TestRequiredOneof, rhs: SwiftProtoTesting_TestRequiredOneof) -> Bool {
     if lhs.foo != rhs.foo {return false}
@@ -6288,16 +5865,10 @@ extension SwiftProtoTesting_TestRequiredOneof.NestedMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._requiredDouble {
-      try visitor.visitSingularDoubleField(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularDouble({ $0.requiredDouble }, fieldNumber: 1, isUnset: { $0._requiredDouble == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestRequiredOneof.NestedMessage, rhs: SwiftProtoTesting_TestRequiredOneof.NestedMessage) -> Bool {
     if lhs._requiredDouble != rhs._requiredDouble {return false}
@@ -6350,51 +5921,23 @@ extension SwiftProtoTesting_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.packedInt32.isEmpty {
-      try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90)
-    }
-    if !self.packedInt64.isEmpty {
-      try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91)
-    }
-    if !self.packedUint32.isEmpty {
-      try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92)
-    }
-    if !self.packedUint64.isEmpty {
-      try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93)
-    }
-    if !self.packedSint32.isEmpty {
-      try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94)
-    }
-    if !self.packedSint64.isEmpty {
-      try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95)
-    }
-    if !self.packedFixed32.isEmpty {
-      try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96)
-    }
-    if !self.packedFixed64.isEmpty {
-      try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97)
-    }
-    if !self.packedSfixed32.isEmpty {
-      try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98)
-    }
-    if !self.packedSfixed64.isEmpty {
-      try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99)
-    }
-    if !self.packedFloat.isEmpty {
-      try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100)
-    }
-    if !self.packedDouble.isEmpty {
-      try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101)
-    }
-    if !self.packedBool.isEmpty {
-      try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102)
-    }
-    if !self.packedEnum.isEmpty {
-      try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .packedInt32({ $0.packedInt32 }, fieldNumber: 90),
+    .packedInt64({ $0.packedInt64 }, fieldNumber: 91),
+    .packedUInt32({ $0.packedUint32 }, fieldNumber: 92),
+    .packedUInt64({ $0.packedUint64 }, fieldNumber: 93),
+    .packedSInt32({ $0.packedSint32 }, fieldNumber: 94),
+    .packedSInt64({ $0.packedSint64 }, fieldNumber: 95),
+    .packedFixed32({ $0.packedFixed32 }, fieldNumber: 96),
+    .packedFixed64({ $0.packedFixed64 }, fieldNumber: 97),
+    .packedSFixed32({ $0.packedSfixed32 }, fieldNumber: 98),
+    .packedSFixed64({ $0.packedSfixed64 }, fieldNumber: 99),
+    .packedFloat({ $0.packedFloat }, fieldNumber: 100),
+    .packedDouble({ $0.packedDouble }, fieldNumber: 101),
+    .packedBool({ $0.packedBool }, fieldNumber: 102),
+    .packedEnum({ $0.packedEnum }, fieldNumber: 103),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestPackedTypes, rhs: SwiftProtoTesting_TestPackedTypes) -> Bool {
     if lhs.packedInt32 != rhs.packedInt32 {return false}
@@ -6460,51 +6003,23 @@ extension SwiftProtoTesting_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.unpackedInt32.isEmpty {
-      try visitor.visitRepeatedInt32Field(value: self.unpackedInt32, fieldNumber: 90)
-    }
-    if !self.unpackedInt64.isEmpty {
-      try visitor.visitRepeatedInt64Field(value: self.unpackedInt64, fieldNumber: 91)
-    }
-    if !self.unpackedUint32.isEmpty {
-      try visitor.visitRepeatedUInt32Field(value: self.unpackedUint32, fieldNumber: 92)
-    }
-    if !self.unpackedUint64.isEmpty {
-      try visitor.visitRepeatedUInt64Field(value: self.unpackedUint64, fieldNumber: 93)
-    }
-    if !self.unpackedSint32.isEmpty {
-      try visitor.visitRepeatedSInt32Field(value: self.unpackedSint32, fieldNumber: 94)
-    }
-    if !self.unpackedSint64.isEmpty {
-      try visitor.visitRepeatedSInt64Field(value: self.unpackedSint64, fieldNumber: 95)
-    }
-    if !self.unpackedFixed32.isEmpty {
-      try visitor.visitRepeatedFixed32Field(value: self.unpackedFixed32, fieldNumber: 96)
-    }
-    if !self.unpackedFixed64.isEmpty {
-      try visitor.visitRepeatedFixed64Field(value: self.unpackedFixed64, fieldNumber: 97)
-    }
-    if !self.unpackedSfixed32.isEmpty {
-      try visitor.visitRepeatedSFixed32Field(value: self.unpackedSfixed32, fieldNumber: 98)
-    }
-    if !self.unpackedSfixed64.isEmpty {
-      try visitor.visitRepeatedSFixed64Field(value: self.unpackedSfixed64, fieldNumber: 99)
-    }
-    if !self.unpackedFloat.isEmpty {
-      try visitor.visitRepeatedFloatField(value: self.unpackedFloat, fieldNumber: 100)
-    }
-    if !self.unpackedDouble.isEmpty {
-      try visitor.visitRepeatedDoubleField(value: self.unpackedDouble, fieldNumber: 101)
-    }
-    if !self.unpackedBool.isEmpty {
-      try visitor.visitRepeatedBoolField(value: self.unpackedBool, fieldNumber: 102)
-    }
-    if !self.unpackedEnum.isEmpty {
-      try visitor.visitRepeatedEnumField(value: self.unpackedEnum, fieldNumber: 103)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .repeatedInt32({ $0.unpackedInt32 }, fieldNumber: 90),
+    .repeatedInt64({ $0.unpackedInt64 }, fieldNumber: 91),
+    .repeatedUInt32({ $0.unpackedUint32 }, fieldNumber: 92),
+    .repeatedUInt64({ $0.unpackedUint64 }, fieldNumber: 93),
+    .repeatedSInt32({ $0.unpackedSint32 }, fieldNumber: 94),
+    .repeatedSInt64({ $0.unpackedSint64 }, fieldNumber: 95),
+    .repeatedFixed32({ $0.unpackedFixed32 }, fieldNumber: 96),
+    .repeatedFixed64({ $0.unpackedFixed64 }, fieldNumber: 97),
+    .repeatedSFixed32({ $0.unpackedSfixed32 }, fieldNumber: 98),
+    .repeatedSFixed64({ $0.unpackedSfixed64 }, fieldNumber: 99),
+    .repeatedFloat({ $0.unpackedFloat }, fieldNumber: 100),
+    .repeatedDouble({ $0.unpackedDouble }, fieldNumber: 101),
+    .repeatedBool({ $0.unpackedBool }, fieldNumber: 102),
+    .repeatedEnum({ $0.unpackedEnum }, fieldNumber: 103),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestUnpackedTypes, rhs: SwiftProtoTesting_TestUnpackedTypes) -> Bool {
     if lhs.unpackedInt32 != rhs.unpackedInt32 {return false}
@@ -6543,10 +6058,10 @@ extension SwiftProtoTesting_TestPackedExtensions: SwiftProtobuf.Message, SwiftPr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1, end: 536870912),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestPackedExtensions, rhs: SwiftProtoTesting_TestPackedExtensions) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -6589,29 +6104,15 @@ extension SwiftProtoTesting_TestParsingMerge: SwiftProtobuf.Message, SwiftProtob
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._requiredAllTypes {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._optionalAllTypes {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-    } }()
-    if !self.repeatedAllTypes.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 3)
-    }
-    try { if let v = self._optionalGroup {
-      try visitor.visitSingularGroupField(value: v, fieldNumber: 10)
-    } }()
-    if !self.repeatedGroup.isEmpty {
-      try visitor.visitRepeatedGroupField(value: self.repeatedGroup, fieldNumber: 20)
-    }
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.requiredAllTypes }, fieldNumber: 1, isUnset: { $0._requiredAllTypes == nil }),
+    .singularMessage({ $0.optionalAllTypes }, fieldNumber: 2, isUnset: { $0._optionalAllTypes == nil }),
+    .repeatedMessage({ $0.repeatedAllTypes }, fieldNumber: 3),
+    .singularGroup({ $0.optionalGroup }, fieldNumber: 10, isUnset: { $0._optionalGroup == nil }),
+    .repeatedGroup({ $0.repeatedGroup }, fieldNumber: 20),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestParsingMerge, rhs: SwiftProtoTesting_TestParsingMerge) -> Bool {
     if lhs._requiredAllTypes != rhs._requiredAllTypes {return false}
@@ -6655,30 +6156,16 @@ extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator: SwiftProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.field1.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1)
-    }
-    if !self.field2.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2)
-    }
-    if !self.field3.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.field3, fieldNumber: 3)
-    }
-    if !self.group1.isEmpty {
-      try visitor.visitRepeatedGroupField(value: self.group1, fieldNumber: 10)
-    }
-    if !self.group2.isEmpty {
-      try visitor.visitRepeatedGroupField(value: self.group2, fieldNumber: 20)
-    }
-    if !self.ext1.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.ext1, fieldNumber: 1000)
-    }
-    if !self.ext2.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.ext2, fieldNumber: 1001)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.field1 }, fieldNumber: 1),
+    .repeatedMessage({ $0.field2 }, fieldNumber: 2),
+    .repeatedMessage({ $0.field3 }, fieldNumber: 3),
+    .repeatedGroup({ $0.group1 }, fieldNumber: 10),
+    .repeatedGroup({ $0.group2 }, fieldNumber: 20),
+    .repeatedMessage({ $0.ext1 }, fieldNumber: 1000),
+    .repeatedMessage({ $0.ext2 }, fieldNumber: 1001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator) -> Bool {
     if lhs.field1 != rhs.field1 {return false}
@@ -6711,16 +6198,10 @@ extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._field1 {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 11)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.field1 }, fieldNumber: 11, isUnset: { $0._field1 == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1) -> Bool {
     if lhs._field1 != rhs._field1 {return false}
@@ -6747,16 +6228,10 @@ extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2: Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._field1 {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 21)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.field1 }, fieldNumber: 21, isUnset: { $0._field1 == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2) -> Bool {
     if lhs._field1 != rhs._field1 {return false}
@@ -6783,16 +6258,10 @@ extension SwiftProtoTesting_TestParsingMerge.OptionalGroup: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._optionalGroupAllTypes {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 11)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.optionalGroupAllTypes }, fieldNumber: 11, isUnset: { $0._optionalGroupAllTypes == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestParsingMerge.OptionalGroup, rhs: SwiftProtoTesting_TestParsingMerge.OptionalGroup) -> Bool {
     if lhs._optionalGroupAllTypes != rhs._optionalGroupAllTypes {return false}
@@ -6819,16 +6288,10 @@ extension SwiftProtoTesting_TestParsingMerge.RepeatedGroup: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._repeatedGroupAllTypes {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 21)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.repeatedGroupAllTypes }, fieldNumber: 21, isUnset: { $0._repeatedGroupAllTypes == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedGroup, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedGroup) -> Bool {
     if lhs._repeatedGroupAllTypes != rhs._repeatedGroupAllTypes {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_import.pb.swift b/Tests/SwiftProtobufTests/unittest_import.pb.swift
index 9eb455720..17a21bbf3 100644
--- a/Tests/SwiftProtobufTests/unittest_import.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_import.pb.swift
@@ -136,16 +136,10 @@ extension SwiftProtoTesting_Import_ImportMessage: SwiftProtobuf.Message, SwiftPr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._d {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.d }, fieldNumber: 1, isUnset: { $0._d == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Import_ImportMessage, rhs: SwiftProtoTesting_Import_ImportMessage) -> Bool {
     if lhs._d != rhs._d {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_import_public.pb.swift b/Tests/SwiftProtobufTests/unittest_import_public.pb.swift
index f8de8e35b..efc20105b 100644
--- a/Tests/SwiftProtobufTests/unittest_import_public.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_import_public.pb.swift
@@ -95,16 +95,10 @@ extension SwiftProtoTesting_Import_PublicImportMessage: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._e {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.e }, fieldNumber: 1, isUnset: { $0._e == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Import_PublicImportMessage, rhs: SwiftProtoTesting_Import_PublicImportMessage) -> Bool {
     if lhs._e != rhs._e {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_mset.pb.swift b/Tests/SwiftProtobufTests/unittest_mset.pb.swift
index 88512c138..a9ad64e32 100644
--- a/Tests/SwiftProtobufTests/unittest_mset.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_mset.pb.swift
@@ -287,16 +287,10 @@ extension SwiftProtoTesting_TestMessageSetContainer: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._messageSet {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.messageSet }, fieldNumber: 1, isUnset: { $0._messageSet == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestMessageSetContainer, rhs: SwiftProtoTesting_TestMessageSetContainer) -> Bool {
     if lhs._messageSet != rhs._messageSet {return false}
@@ -332,22 +326,12 @@ extension SwiftProtoTesting_TestMessageSetExtension1: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._i {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 15)
-    } }()
-    try { if let v = self._recursive {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 16)
-    } }()
-    try { if let v = self._testAliasing {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 17)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.i }, fieldNumber: 15, isUnset: { $0._i == nil }),
+    .singularMessage({ $0.recursive }, fieldNumber: 16, isUnset: { $0._recursive == nil }),
+    .singularString({ $0.testAliasing }, fieldNumber: 17, isUnset: { $0._testAliasing == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestMessageSetExtension1, rhs: SwiftProtoTesting_TestMessageSetExtension1) -> Bool {
     if lhs._i != rhs._i {return false}
@@ -376,16 +360,10 @@ extension SwiftProtoTesting_TestMessageSetExtension2: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._str {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 25)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularString({ $0.str }, fieldNumber: 25, isUnset: { $0._str == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestMessageSetExtension2, rhs: SwiftProtoTesting_TestMessageSetExtension2) -> Bool {
     if lhs._str != rhs._str {return false}
@@ -417,12 +395,10 @@ extension SwiftProtoTesting_RawMessageSet: SwiftProtobuf.Message, SwiftProtobuf.
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.item.isEmpty {
-      try visitor.visitRepeatedGroupField(value: self.item, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .repeatedGroup({ $0.item }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_RawMessageSet, rhs: SwiftProtoTesting_RawMessageSet) -> Bool {
     if lhs.item != rhs.item {return false}
@@ -457,19 +433,11 @@ extension SwiftProtoTesting_RawMessageSet.Item: SwiftProtobuf.Message, SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._typeID {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._message {
-      try visitor.visitSingularBytesField(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.typeID }, fieldNumber: 2, isUnset: { $0._typeID == nil }),
+    .singularBytes({ $0.message }, fieldNumber: 3, isUnset: { $0._message == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_RawMessageSet.Item, rhs: SwiftProtoTesting_RawMessageSet.Item) -> Bool {
     if lhs._typeID != rhs._typeID {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift b/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift
index bcd69ba05..ad570d065 100644
--- a/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift
@@ -86,10 +86,10 @@ extension SwiftProtoTesting_WireFormat_TestMessageSet: SwiftProtobuf.Message, Sw
     try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_WireFormat_TestMessageSet.self)
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFieldsAsMessageSet({ $0._protobuf_extensionFieldValues }, start: 4, end: 2147483647),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_WireFormat_TestMessageSet, rhs: SwiftProtoTesting_WireFormat_TestMessageSet) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift b/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift
index aac6b31bf..6305953c7 100644
--- a/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift
@@ -278,36 +278,23 @@ extension SwiftProtoTesting_UnknownEnum_Proto3_MyMessage: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if self.e != .foo {
-      try visitor.visitSingularEnumField(value: self.e, fieldNumber: 1)
-    }
-    if !self.repeatedE.isEmpty {
-      try visitor.visitPackedEnumField(value: self.repeatedE, fieldNumber: 2)
-    }
-    if !self.repeatedPackedE.isEmpty {
-      try visitor.visitPackedEnumField(value: self.repeatedPackedE, fieldNumber: 3)
-    }
-    if !self.repeatedPackedUnexpectedE.isEmpty {
-      try visitor.visitPackedEnumField(value: self.repeatedPackedUnexpectedE, fieldNumber: 4)
-    }
-    switch self.o {
-    case .oneofE1?: try {
-      guard case .oneofE1(let v)? = self.o else { preconditionFailure() }
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 5)
-    }()
-    case .oneofE2?: try {
-      guard case .oneofE2(let v)? = self.o else { preconditionFailure() }
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 6)
-    }()
-    case nil: break
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularEnum({ $0.e }, fieldNumber: 1, defaultValue: .foo),
+    .packedEnum({ $0.repeatedE }, fieldNumber: 2),
+    .packedEnum({ $0.repeatedPackedE }, fieldNumber: 3),
+    .packedEnum({ $0.repeatedPackedUnexpectedE }, fieldNumber: 4),
+    .oneOf({ $0.o }) {
+      switch $0 {
+      case .oneofE1:
+        return _oneOfField_oneofE1
+      case .oneofE2:
+        return _oneOfField_oneofE2
+      }
+    },
+  ]
+  private static let _oneOfField_oneofE1: Field<Self> = .singularEnum({ $0.oneofE1 }, fieldNumber: 5, isUnset: { _ in false })
+  private static let _oneOfField_oneofE2: Field<Self> = .singularEnum({ $0.oneofE2 }, fieldNumber: 6, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessage, rhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessage) -> Bool {
     if lhs.e != rhs.e {return false}
@@ -362,36 +349,23 @@ extension SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra: SwiftProtobuf
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if self.e != .eFoo {
-      try visitor.visitSingularEnumField(value: self.e, fieldNumber: 1)
-    }
-    if !self.repeatedE.isEmpty {
-      try visitor.visitPackedEnumField(value: self.repeatedE, fieldNumber: 2)
-    }
-    if !self.repeatedPackedE.isEmpty {
-      try visitor.visitPackedEnumField(value: self.repeatedPackedE, fieldNumber: 3)
-    }
-    if !self.repeatedPackedUnexpectedE.isEmpty {
-      try visitor.visitPackedEnumField(value: self.repeatedPackedUnexpectedE, fieldNumber: 4)
-    }
-    switch self.o {
-    case .oneofE1?: try {
-      guard case .oneofE1(let v)? = self.o else { preconditionFailure() }
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 5)
-    }()
-    case .oneofE2?: try {
-      guard case .oneofE2(let v)? = self.o else { preconditionFailure() }
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 6)
-    }()
-    case nil: break
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularEnum({ $0.e }, fieldNumber: 1, defaultValue: .eFoo),
+    .packedEnum({ $0.repeatedE }, fieldNumber: 2),
+    .packedEnum({ $0.repeatedPackedE }, fieldNumber: 3),
+    .packedEnum({ $0.repeatedPackedUnexpectedE }, fieldNumber: 4),
+    .oneOf({ $0.o }) {
+      switch $0 {
+      case .oneofE1:
+        return _oneOfField_oneofE1
+      case .oneofE2:
+        return _oneOfField_oneofE2
+      }
+    },
+  ]
+  private static let _oneOfField_oneofE1: Field<Self> = .singularEnum({ $0.oneofE1 }, fieldNumber: 5, isUnset: { _ in false })
+  private static let _oneOfField_oneofE2: Field<Self> = .singularEnum({ $0.oneofE2 }, fieldNumber: 6, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra, rhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra) -> Bool {
     if lhs.e != rhs.e {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift b/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift
index 406ca934d..76b3756fc 100644
--- a/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift
@@ -185,36 +185,23 @@ extension SwiftProtoTesting_UnknownEnum_Proto2_MyMessage: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._e {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
-    } }()
-    if !self.repeatedE.isEmpty {
-      try visitor.visitRepeatedEnumField(value: self.repeatedE, fieldNumber: 2)
-    }
-    if !self.repeatedPackedE.isEmpty {
-      try visitor.visitPackedEnumField(value: self.repeatedPackedE, fieldNumber: 3)
-    }
-    if !self.repeatedPackedUnexpectedE.isEmpty {
-      try visitor.visitRepeatedEnumField(value: self.repeatedPackedUnexpectedE, fieldNumber: 4)
-    }
-    switch self.o {
-    case .oneofE1?: try {
-      guard case .oneofE1(let v)? = self.o else { preconditionFailure() }
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 5)
-    }()
-    case .oneofE2?: try {
-      guard case .oneofE2(let v)? = self.o else { preconditionFailure() }
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 6)
-    }()
-    case nil: break
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularEnum({ $0.e }, fieldNumber: 1, isUnset: { $0._e == nil }),
+    .repeatedEnum({ $0.repeatedE }, fieldNumber: 2),
+    .packedEnum({ $0.repeatedPackedE }, fieldNumber: 3),
+    .repeatedEnum({ $0.repeatedPackedUnexpectedE }, fieldNumber: 4),
+    .oneOf({ $0.o }) {
+      switch $0 {
+      case .oneofE1:
+        return _oneOfField_oneofE1
+      case .oneofE2:
+        return _oneOfField_oneofE2
+      }
+    },
+  ]
+  private static let _oneOfField_oneofE1: Field<Self> = .singularEnum({ $0.oneofE1 }, fieldNumber: 5, isUnset: { _ in false })
+  private static let _oneOfField_oneofE2: Field<Self> = .singularEnum({ $0.oneofE2 }, fieldNumber: 6, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_UnknownEnum_Proto2_MyMessage, rhs: SwiftProtoTesting_UnknownEnum_Proto2_MyMessage) -> Bool {
     if lhs._e != rhs._e {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_proto3.pb.swift b/Tests/SwiftProtobufTests/unittest_proto3.pb.swift
index 87f861d19..dbc0a56b1 100644
--- a/Tests/SwiftProtobufTests/unittest_proto3.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_proto3.pb.swift
@@ -933,181 +933,74 @@ extension SwiftProtoTesting_Proto3_TestAllTypes: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      if _storage._optionalInt32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1)
-      }
-      if _storage._optionalInt64 != 0 {
-        try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2)
-      }
-      if _storage._optionalUint32 != 0 {
-        try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3)
-      }
-      if _storage._optionalUint64 != 0 {
-        try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4)
-      }
-      if _storage._optionalSint32 != 0 {
-        try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5)
-      }
-      if _storage._optionalSint64 != 0 {
-        try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6)
-      }
-      if _storage._optionalFixed32 != 0 {
-        try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7)
-      }
-      if _storage._optionalFixed64 != 0 {
-        try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8)
-      }
-      if _storage._optionalSfixed32 != 0 {
-        try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9)
-      }
-      if _storage._optionalSfixed64 != 0 {
-        try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10)
-      }
-      if _storage._optionalFloat != 0 {
-        try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11)
-      }
-      if _storage._optionalDouble != 0 {
-        try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12)
-      }
-      if _storage._optionalBool != false {
-        try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13)
-      }
-      if !_storage._optionalString.isEmpty {
-        try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14)
-      }
-      if !_storage._optionalBytes.isEmpty {
-        try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15)
-      }
-      try { if let v = _storage._optionalNestedMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._optionalForeignMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 19)
-      } }()
-      try { if let v = _storage._optionalImportMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 20)
-      } }()
-      if _storage._optionalNestedEnum != .zero {
-        try visitor.visitSingularEnumField(value: _storage._optionalNestedEnum, fieldNumber: 21)
-      }
-      if _storage._optionalForeignEnum != .foreignZero {
-        try visitor.visitSingularEnumField(value: _storage._optionalForeignEnum, fieldNumber: 22)
-      }
-      if !_storage._optionalStringPiece.isEmpty {
-        try visitor.visitSingularStringField(value: _storage._optionalStringPiece, fieldNumber: 24)
-      }
-      if !_storage._optionalCord.isEmpty {
-        try visitor.visitSingularStringField(value: _storage._optionalCord, fieldNumber: 25)
-      }
-      try { if let v = _storage._optionalPublicImportMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 26)
-      } }()
-      try { if let v = _storage._optionalLazyMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 27)
-      } }()
-      try { if let v = _storage._optionalUnverifiedLazyMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 28)
-      } }()
-      if !_storage._repeatedInt32.isEmpty {
-        try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31)
-      }
-      if !_storage._repeatedInt64.isEmpty {
-        try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32)
-      }
-      if !_storage._repeatedUint32.isEmpty {
-        try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33)
-      }
-      if !_storage._repeatedUint64.isEmpty {
-        try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34)
-      }
-      if !_storage._repeatedSint32.isEmpty {
-        try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35)
-      }
-      if !_storage._repeatedSint64.isEmpty {
-        try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36)
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalInt32 }, fieldNumber: 1),
+    .singularInt64({ $0.optionalInt64 }, fieldNumber: 2),
+    .singularUInt32({ $0.optionalUint32 }, fieldNumber: 3),
+    .singularUInt64({ $0.optionalUint64 }, fieldNumber: 4),
+    .singularSInt32({ $0.optionalSint32 }, fieldNumber: 5),
+    .singularSInt64({ $0.optionalSint64 }, fieldNumber: 6),
+    .singularFixed32({ $0.optionalFixed32 }, fieldNumber: 7),
+    .singularFixed64({ $0.optionalFixed64 }, fieldNumber: 8),
+    .singularSFixed32({ $0.optionalSfixed32 }, fieldNumber: 9),
+    .singularSFixed64({ $0.optionalSfixed64 }, fieldNumber: 10),
+    .singularFloat({ $0.optionalFloat }, fieldNumber: 11),
+    .singularDouble({ $0.optionalDouble }, fieldNumber: 12),
+    .singularBool({ $0.optionalBool }, fieldNumber: 13),
+    .singularString({ $0.optionalString }, fieldNumber: 14),
+    .singularBytes({ $0.optionalBytes }, fieldNumber: 15),
+    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
+    .singularMessage({ $0.optionalForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._optionalForeignMessage == nil }),
+    .singularMessage({ $0.optionalImportMessage }, fieldNumber: 20, isUnset: { $0._storage._optionalImportMessage == nil }),
+    .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, defaultValue: .zero),
+    .singularEnum({ $0.optionalForeignEnum }, fieldNumber: 22, defaultValue: .foreignZero),
+    .singularString({ $0.optionalStringPiece }, fieldNumber: 24),
+    .singularString({ $0.optionalCord }, fieldNumber: 25),
+    .singularMessage({ $0.optionalPublicImportMessage }, fieldNumber: 26, isUnset: { $0._storage._optionalPublicImportMessage == nil }),
+    .singularMessage({ $0.optionalLazyMessage }, fieldNumber: 27, isUnset: { $0._storage._optionalLazyMessage == nil }),
+    .singularMessage({ $0.optionalUnverifiedLazyMessage }, fieldNumber: 28, isUnset: { $0._storage._optionalUnverifiedLazyMessage == nil }),
+    .packedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
+    .packedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
+    .packedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
+    .packedUInt64({ $0.repeatedUint64 }, fieldNumber: 34),
+    .packedSInt32({ $0.repeatedSint32 }, fieldNumber: 35),
+    .packedSInt64({ $0.repeatedSint64 }, fieldNumber: 36),
+    .packedFixed32({ $0.repeatedFixed32 }, fieldNumber: 37),
+    .packedFixed64({ $0.repeatedFixed64 }, fieldNumber: 38),
+    .packedSFixed32({ $0.repeatedSfixed32 }, fieldNumber: 39),
+    .packedSFixed64({ $0.repeatedSfixed64 }, fieldNumber: 40),
+    .packedFloat({ $0.repeatedFloat }, fieldNumber: 41),
+    .packedDouble({ $0.repeatedDouble }, fieldNumber: 42),
+    .packedBool({ $0.repeatedBool }, fieldNumber: 43),
+    .repeatedString({ $0.repeatedString }, fieldNumber: 44),
+    .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
+    .repeatedMessage({ $0.repeatedNestedMessage }, fieldNumber: 48),
+    .repeatedMessage({ $0.repeatedForeignMessage }, fieldNumber: 49),
+    .repeatedMessage({ $0.repeatedImportMessage }, fieldNumber: 50),
+    .packedEnum({ $0.repeatedNestedEnum }, fieldNumber: 51),
+    .packedEnum({ $0.repeatedForeignEnum }, fieldNumber: 52),
+    .repeatedString({ $0.repeatedStringPiece }, fieldNumber: 54),
+    .repeatedString({ $0.repeatedCord }, fieldNumber: 55),
+    .repeatedMessage({ $0.repeatedLazyMessage }, fieldNumber: 57),
+    .oneOf({ $0.oneofField }) {
+      switch $0 {
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofNestedMessage:
+        return _oneOfField_oneofNestedMessage
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
       }
-      if !_storage._repeatedFixed32.isEmpty {
-        try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37)
-      }
-      if !_storage._repeatedFixed64.isEmpty {
-        try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38)
-      }
-      if !_storage._repeatedSfixed32.isEmpty {
-        try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39)
-      }
-      if !_storage._repeatedSfixed64.isEmpty {
-        try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40)
-      }
-      if !_storage._repeatedFloat.isEmpty {
-        try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41)
-      }
-      if !_storage._repeatedDouble.isEmpty {
-        try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42)
-      }
-      if !_storage._repeatedBool.isEmpty {
-        try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43)
-      }
-      if !_storage._repeatedString.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44)
-      }
-      if !_storage._repeatedBytes.isEmpty {
-        try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45)
-      }
-      if !_storage._repeatedNestedMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48)
-      }
-      if !_storage._repeatedForeignMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49)
-      }
-      if !_storage._repeatedImportMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50)
-      }
-      if !_storage._repeatedNestedEnum.isEmpty {
-        try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51)
-      }
-      if !_storage._repeatedForeignEnum.isEmpty {
-        try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52)
-      }
-      if !_storage._repeatedStringPiece.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54)
-      }
-      if !_storage._repeatedCord.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55)
-      }
-      if !_storage._repeatedLazyMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57)
-      }
-      switch _storage._oneofField {
-      case .oneofUint32?: try {
-        guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111)
-      }()
-      case .oneofNestedMessage?: try {
-        guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 112)
-      }()
-      case .oneofString?: try {
-        guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularStringField(value: v, fieldNumber: 113)
-      }()
-      case .oneofBytes?: try {
-        guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 114)
-      }()
-      case nil: break
-      }
-      try { if let v = _storage._optionalLazyImportMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 115)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+    },
+    .singularMessage({ $0.optionalLazyImportMessage }, fieldNumber: 115, isUnset: { $0._storage._optionalLazyImportMessage == nil }),
+  ]
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Proto3_TestAllTypes, rhs: SwiftProtoTesting_Proto3_TestAllTypes) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -1201,12 +1094,10 @@ extension SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage: SwiftProtobuf.Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.bb != 0 {
-      try visitor.visitSingularInt32Field(value: self.bb, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bb }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage, rhs: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage) -> Bool {
     if lhs.bb != rhs.bb {return false}
@@ -1259,51 +1150,23 @@ extension SwiftProtoTesting_Proto3_TestPackedTypes: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.packedInt32.isEmpty {
-      try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90)
-    }
-    if !self.packedInt64.isEmpty {
-      try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91)
-    }
-    if !self.packedUint32.isEmpty {
-      try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92)
-    }
-    if !self.packedUint64.isEmpty {
-      try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93)
-    }
-    if !self.packedSint32.isEmpty {
-      try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94)
-    }
-    if !self.packedSint64.isEmpty {
-      try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95)
-    }
-    if !self.packedFixed32.isEmpty {
-      try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96)
-    }
-    if !self.packedFixed64.isEmpty {
-      try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97)
-    }
-    if !self.packedSfixed32.isEmpty {
-      try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98)
-    }
-    if !self.packedSfixed64.isEmpty {
-      try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99)
-    }
-    if !self.packedFloat.isEmpty {
-      try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100)
-    }
-    if !self.packedDouble.isEmpty {
-      try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101)
-    }
-    if !self.packedBool.isEmpty {
-      try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102)
-    }
-    if !self.packedEnum.isEmpty {
-      try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .packedInt32({ $0.packedInt32 }, fieldNumber: 90),
+    .packedInt64({ $0.packedInt64 }, fieldNumber: 91),
+    .packedUInt32({ $0.packedUint32 }, fieldNumber: 92),
+    .packedUInt64({ $0.packedUint64 }, fieldNumber: 93),
+    .packedSInt32({ $0.packedSint32 }, fieldNumber: 94),
+    .packedSInt64({ $0.packedSint64 }, fieldNumber: 95),
+    .packedFixed32({ $0.packedFixed32 }, fieldNumber: 96),
+    .packedFixed64({ $0.packedFixed64 }, fieldNumber: 97),
+    .packedSFixed32({ $0.packedSfixed32 }, fieldNumber: 98),
+    .packedSFixed64({ $0.packedSfixed64 }, fieldNumber: 99),
+    .packedFloat({ $0.packedFloat }, fieldNumber: 100),
+    .packedDouble({ $0.packedDouble }, fieldNumber: 101),
+    .packedBool({ $0.packedBool }, fieldNumber: 102),
+    .packedEnum({ $0.packedEnum }, fieldNumber: 103),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Proto3_TestPackedTypes, rhs: SwiftProtoTesting_Proto3_TestPackedTypes) -> Bool {
     if lhs.packedInt32 != rhs.packedInt32 {return false}
@@ -1369,51 +1232,23 @@ extension SwiftProtoTesting_Proto3_TestUnpackedTypes: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.repeatedInt32.isEmpty {
-      try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 1)
-    }
-    if !self.repeatedInt64.isEmpty {
-      try visitor.visitRepeatedInt64Field(value: self.repeatedInt64, fieldNumber: 2)
-    }
-    if !self.repeatedUint32.isEmpty {
-      try visitor.visitRepeatedUInt32Field(value: self.repeatedUint32, fieldNumber: 3)
-    }
-    if !self.repeatedUint64.isEmpty {
-      try visitor.visitRepeatedUInt64Field(value: self.repeatedUint64, fieldNumber: 4)
-    }
-    if !self.repeatedSint32.isEmpty {
-      try visitor.visitRepeatedSInt32Field(value: self.repeatedSint32, fieldNumber: 5)
-    }
-    if !self.repeatedSint64.isEmpty {
-      try visitor.visitRepeatedSInt64Field(value: self.repeatedSint64, fieldNumber: 6)
-    }
-    if !self.repeatedFixed32.isEmpty {
-      try visitor.visitRepeatedFixed32Field(value: self.repeatedFixed32, fieldNumber: 7)
-    }
-    if !self.repeatedFixed64.isEmpty {
-      try visitor.visitRepeatedFixed64Field(value: self.repeatedFixed64, fieldNumber: 8)
-    }
-    if !self.repeatedSfixed32.isEmpty {
-      try visitor.visitRepeatedSFixed32Field(value: self.repeatedSfixed32, fieldNumber: 9)
-    }
-    if !self.repeatedSfixed64.isEmpty {
-      try visitor.visitRepeatedSFixed64Field(value: self.repeatedSfixed64, fieldNumber: 10)
-    }
-    if !self.repeatedFloat.isEmpty {
-      try visitor.visitRepeatedFloatField(value: self.repeatedFloat, fieldNumber: 11)
-    }
-    if !self.repeatedDouble.isEmpty {
-      try visitor.visitRepeatedDoubleField(value: self.repeatedDouble, fieldNumber: 12)
-    }
-    if !self.repeatedBool.isEmpty {
-      try visitor.visitRepeatedBoolField(value: self.repeatedBool, fieldNumber: 13)
-    }
-    if !self.repeatedNestedEnum.isEmpty {
-      try visitor.visitRepeatedEnumField(value: self.repeatedNestedEnum, fieldNumber: 14)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 1),
+    .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 2),
+    .repeatedUInt32({ $0.repeatedUint32 }, fieldNumber: 3),
+    .repeatedUInt64({ $0.repeatedUint64 }, fieldNumber: 4),
+    .repeatedSInt32({ $0.repeatedSint32 }, fieldNumber: 5),
+    .repeatedSInt64({ $0.repeatedSint64 }, fieldNumber: 6),
+    .repeatedFixed32({ $0.repeatedFixed32 }, fieldNumber: 7),
+    .repeatedFixed64({ $0.repeatedFixed64 }, fieldNumber: 8),
+    .repeatedSFixed32({ $0.repeatedSfixed32 }, fieldNumber: 9),
+    .repeatedSFixed64({ $0.repeatedSfixed64 }, fieldNumber: 10),
+    .repeatedFloat({ $0.repeatedFloat }, fieldNumber: 11),
+    .repeatedDouble({ $0.repeatedDouble }, fieldNumber: 12),
+    .repeatedBool({ $0.repeatedBool }, fieldNumber: 13),
+    .repeatedEnum({ $0.repeatedNestedEnum }, fieldNumber: 14),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Proto3_TestUnpackedTypes, rhs: SwiftProtoTesting_Proto3_TestUnpackedTypes) -> Bool {
     if lhs.repeatedInt32 != rhs.repeatedInt32 {return false}
@@ -1479,21 +1314,11 @@ extension SwiftProtoTesting_Proto3_NestedTestAllTypes: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._child {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._payload {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.child }, fieldNumber: 1, isUnset: { $0._storage._child == nil }),
+    .singularMessage({ $0.payload }, fieldNumber: 2, isUnset: { $0._storage._payload == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Proto3_NestedTestAllTypes, rhs: SwiftProtoTesting_Proto3_NestedTestAllTypes) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -1529,12 +1354,10 @@ extension SwiftProtoTesting_Proto3_ForeignMessage: SwiftProtobuf.Message, SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.c != 0 {
-      try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.c }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Proto3_ForeignMessage, rhs: SwiftProtoTesting_Proto3_ForeignMessage) -> Bool {
     if lhs.c != rhs.c {return false}
@@ -1552,9 +1375,9 @@ extension SwiftProtoTesting_Proto3_TestEmptyMessage: SwiftProtobuf.Message, Swif
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Proto3_TestEmptyMessage, rhs: SwiftProtoTesting_Proto3_TestEmptyMessage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -1585,16 +1408,10 @@ extension SwiftProtoTesting_Proto3_TestProto2Required: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._proto2 {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.proto2 }, fieldNumber: 1, isUnset: { $0._proto2 == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Proto3_TestProto2Required, rhs: SwiftProtoTesting_Proto3_TestProto2Required) -> Bool {
     if lhs._proto2 != rhs._proto2 {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift b/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift
index 81a11ccaa..3fa4860c8 100644
--- a/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift
@@ -441,78 +441,30 @@ extension SwiftProtoTesting_TestProto3Optional: SwiftProtobuf.Message, SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._optionalInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._optionalInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._optionalUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._optionalUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._optionalSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._optionalSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._optionalFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._optionalFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._optionalSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._optionalSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._optionalFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._optionalDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._optionalBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._optionalString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._optionalBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._optionalCord {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._optionalNestedMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._lazyNestedMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 19)
-      } }()
-      try { if let v = _storage._optionalNestedEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 21)
-      } }()
-      if _storage._singularInt32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._singularInt32, fieldNumber: 22)
-      }
-      if _storage._singularInt64 != 0 {
-        try visitor.visitSingularInt64Field(value: _storage._singularInt64, fieldNumber: 23)
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalInt32 }, fieldNumber: 1, isUnset: { $0._storage._optionalInt32 == nil }),
+    .singularInt64({ $0.optionalInt64 }, fieldNumber: 2, isUnset: { $0._storage._optionalInt64 == nil }),
+    .singularUInt32({ $0.optionalUint32 }, fieldNumber: 3, isUnset: { $0._storage._optionalUint32 == nil }),
+    .singularUInt64({ $0.optionalUint64 }, fieldNumber: 4, isUnset: { $0._storage._optionalUint64 == nil }),
+    .singularSInt32({ $0.optionalSint32 }, fieldNumber: 5, isUnset: { $0._storage._optionalSint32 == nil }),
+    .singularSInt64({ $0.optionalSint64 }, fieldNumber: 6, isUnset: { $0._storage._optionalSint64 == nil }),
+    .singularFixed32({ $0.optionalFixed32 }, fieldNumber: 7, isUnset: { $0._storage._optionalFixed32 == nil }),
+    .singularFixed64({ $0.optionalFixed64 }, fieldNumber: 8, isUnset: { $0._storage._optionalFixed64 == nil }),
+    .singularSFixed32({ $0.optionalSfixed32 }, fieldNumber: 9, isUnset: { $0._storage._optionalSfixed32 == nil }),
+    .singularSFixed64({ $0.optionalSfixed64 }, fieldNumber: 10, isUnset: { $0._storage._optionalSfixed64 == nil }),
+    .singularFloat({ $0.optionalFloat }, fieldNumber: 11, isUnset: { $0._storage._optionalFloat == nil }),
+    .singularDouble({ $0.optionalDouble }, fieldNumber: 12, isUnset: { $0._storage._optionalDouble == nil }),
+    .singularBool({ $0.optionalBool }, fieldNumber: 13, isUnset: { $0._storage._optionalBool == nil }),
+    .singularString({ $0.optionalString }, fieldNumber: 14, isUnset: { $0._storage._optionalString == nil }),
+    .singularBytes({ $0.optionalBytes }, fieldNumber: 15, isUnset: { $0._storage._optionalBytes == nil }),
+    .singularString({ $0.optionalCord }, fieldNumber: 16, isUnset: { $0._storage._optionalCord == nil }),
+    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
+    .singularMessage({ $0.lazyNestedMessage }, fieldNumber: 19, isUnset: { $0._storage._lazyNestedMessage == nil }),
+    .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, isUnset: { $0._storage._optionalNestedEnum == nil }),
+    .singularInt32({ $0.singularInt32 }, fieldNumber: 22),
+    .singularInt64({ $0.singularInt64 }, fieldNumber: 23),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestProto3Optional, rhs: SwiftProtoTesting_TestProto3Optional) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -577,16 +529,10 @@ extension SwiftProtoTesting_TestProto3Optional.NestedMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._bb {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bb }, fieldNumber: 1, isUnset: { $0._bb == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestProto3Optional.NestedMessage, rhs: SwiftProtoTesting_TestProto3Optional.NestedMessage) -> Bool {
     if lhs._bb != rhs._bb {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift
index 6638e4d40..bdcee6100 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift
@@ -1030,172 +1030,71 @@ extension SwiftProtoTesting_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._requiredInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._requiredInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._requiredUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._requiredUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._requiredSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._requiredSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._requiredFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._requiredFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._requiredSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._requiredSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._requiredFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._requiredDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._requiredBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._requiredString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._requiredBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._requiredGroup {
-        try visitor.visitSingularGroupField(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._requiredNestedMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._requiredForeignMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 19)
-      } }()
-      try { if let v = _storage._requiredImportMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 20)
-      } }()
-      try { if let v = _storage._requiredNestedEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 21)
-      } }()
-      try { if let v = _storage._requiredForeignEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 22)
-      } }()
-      try { if let v = _storage._requiredImportEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 23)
-      } }()
-      try { if let v = _storage._requiredStringPiece {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 24)
-      } }()
-      try { if let v = _storage._requiredCord {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 25)
-      } }()
-      try { if let v = _storage._requiredPublicImportMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 26)
-      } }()
-      try { if let v = _storage._requiredLazyMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 27)
-      } }()
-      try { if let v = _storage._defaultInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 61)
-      } }()
-      try { if let v = _storage._defaultInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 62)
-      } }()
-      try { if let v = _storage._defaultUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63)
-      } }()
-      try { if let v = _storage._defaultUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64)
-      } }()
-      try { if let v = _storage._defaultSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65)
-      } }()
-      try { if let v = _storage._defaultSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66)
-      } }()
-      try { if let v = _storage._defaultFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67)
-      } }()
-      try { if let v = _storage._defaultFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68)
-      } }()
-      try { if let v = _storage._defaultSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69)
-      } }()
-      try { if let v = _storage._defaultSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70)
-      } }()
-      try { if let v = _storage._defaultFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 71)
-      } }()
-      try { if let v = _storage._defaultDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 72)
-      } }()
-      try { if let v = _storage._defaultBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 73)
-      } }()
-      try { if let v = _storage._defaultString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 74)
-      } }()
-      try { if let v = _storage._defaultBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 75)
-      } }()
-      try { if let v = _storage._defaultNestedEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 81)
-      } }()
-      try { if let v = _storage._defaultForeignEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 82)
-      } }()
-      try { if let v = _storage._defaultImportEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 83)
-      } }()
-      try { if let v = _storage._defaultStringPiece {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 84)
-      } }()
-      try { if let v = _storage._defaultCord {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 85)
-      } }()
-      switch _storage._oneofField {
-      case .oneofUint32?: try {
-        guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111)
-      }()
-      case .oneofNestedMessage?: try {
-        guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 112)
-      }()
-      case .oneofString?: try {
-        guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularStringField(value: v, fieldNumber: 113)
-      }()
-      case .oneofBytes?: try {
-        guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() }
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 114)
-      }()
-      case nil: break
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.requiredInt32 }, fieldNumber: 1, isUnset: { $0._storage._requiredInt32 == nil }),
+    .singularInt64({ $0.requiredInt64 }, fieldNumber: 2, isUnset: { $0._storage._requiredInt64 == nil }),
+    .singularUInt32({ $0.requiredUint32 }, fieldNumber: 3, isUnset: { $0._storage._requiredUint32 == nil }),
+    .singularUInt64({ $0.requiredUint64 }, fieldNumber: 4, isUnset: { $0._storage._requiredUint64 == nil }),
+    .singularSInt32({ $0.requiredSint32 }, fieldNumber: 5, isUnset: { $0._storage._requiredSint32 == nil }),
+    .singularSInt64({ $0.requiredSint64 }, fieldNumber: 6, isUnset: { $0._storage._requiredSint64 == nil }),
+    .singularFixed32({ $0.requiredFixed32 }, fieldNumber: 7, isUnset: { $0._storage._requiredFixed32 == nil }),
+    .singularFixed64({ $0.requiredFixed64 }, fieldNumber: 8, isUnset: { $0._storage._requiredFixed64 == nil }),
+    .singularSFixed32({ $0.requiredSfixed32 }, fieldNumber: 9, isUnset: { $0._storage._requiredSfixed32 == nil }),
+    .singularSFixed64({ $0.requiredSfixed64 }, fieldNumber: 10, isUnset: { $0._storage._requiredSfixed64 == nil }),
+    .singularFloat({ $0.requiredFloat }, fieldNumber: 11, isUnset: { $0._storage._requiredFloat == nil }),
+    .singularDouble({ $0.requiredDouble }, fieldNumber: 12, isUnset: { $0._storage._requiredDouble == nil }),
+    .singularBool({ $0.requiredBool }, fieldNumber: 13, isUnset: { $0._storage._requiredBool == nil }),
+    .singularString({ $0.requiredString }, fieldNumber: 14, isUnset: { $0._storage._requiredString == nil }),
+    .singularBytes({ $0.requiredBytes }, fieldNumber: 15, isUnset: { $0._storage._requiredBytes == nil }),
+    .singularGroup({ $0.requiredGroup }, fieldNumber: 16, isUnset: { $0._storage._requiredGroup == nil }),
+    .singularMessage({ $0.requiredNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._requiredNestedMessage == nil }),
+    .singularMessage({ $0.requiredForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._requiredForeignMessage == nil }),
+    .singularMessage({ $0.requiredImportMessage }, fieldNumber: 20, isUnset: { $0._storage._requiredImportMessage == nil }),
+    .singularEnum({ $0.requiredNestedEnum }, fieldNumber: 21, isUnset: { $0._storage._requiredNestedEnum == nil }),
+    .singularEnum({ $0.requiredForeignEnum }, fieldNumber: 22, isUnset: { $0._storage._requiredForeignEnum == nil }),
+    .singularEnum({ $0.requiredImportEnum }, fieldNumber: 23, isUnset: { $0._storage._requiredImportEnum == nil }),
+    .singularString({ $0.requiredStringPiece }, fieldNumber: 24, isUnset: { $0._storage._requiredStringPiece == nil }),
+    .singularString({ $0.requiredCord }, fieldNumber: 25, isUnset: { $0._storage._requiredCord == nil }),
+    .singularMessage({ $0.requiredPublicImportMessage }, fieldNumber: 26, isUnset: { $0._storage._requiredPublicImportMessage == nil }),
+    .singularMessage({ $0.requiredLazyMessage }, fieldNumber: 27, isUnset: { $0._storage._requiredLazyMessage == nil }),
+    .singularInt32({ $0.defaultInt32 }, fieldNumber: 61, isUnset: { $0._storage._defaultInt32 == nil }),
+    .singularInt64({ $0.defaultInt64 }, fieldNumber: 62, isUnset: { $0._storage._defaultInt64 == nil }),
+    .singularUInt32({ $0.defaultUint32 }, fieldNumber: 63, isUnset: { $0._storage._defaultUint32 == nil }),
+    .singularUInt64({ $0.defaultUint64 }, fieldNumber: 64, isUnset: { $0._storage._defaultUint64 == nil }),
+    .singularSInt32({ $0.defaultSint32 }, fieldNumber: 65, isUnset: { $0._storage._defaultSint32 == nil }),
+    .singularSInt64({ $0.defaultSint64 }, fieldNumber: 66, isUnset: { $0._storage._defaultSint64 == nil }),
+    .singularFixed32({ $0.defaultFixed32 }, fieldNumber: 67, isUnset: { $0._storage._defaultFixed32 == nil }),
+    .singularFixed64({ $0.defaultFixed64 }, fieldNumber: 68, isUnset: { $0._storage._defaultFixed64 == nil }),
+    .singularSFixed32({ $0.defaultSfixed32 }, fieldNumber: 69, isUnset: { $0._storage._defaultSfixed32 == nil }),
+    .singularSFixed64({ $0.defaultSfixed64 }, fieldNumber: 70, isUnset: { $0._storage._defaultSfixed64 == nil }),
+    .singularFloat({ $0.defaultFloat }, fieldNumber: 71, isUnset: { $0._storage._defaultFloat == nil }),
+    .singularDouble({ $0.defaultDouble }, fieldNumber: 72, isUnset: { $0._storage._defaultDouble == nil }),
+    .singularBool({ $0.defaultBool }, fieldNumber: 73, isUnset: { $0._storage._defaultBool == nil }),
+    .singularString({ $0.defaultString }, fieldNumber: 74, isUnset: { $0._storage._defaultString == nil }),
+    .singularBytes({ $0.defaultBytes }, fieldNumber: 75, isUnset: { $0._storage._defaultBytes == nil }),
+    .singularEnum({ $0.defaultNestedEnum }, fieldNumber: 81, isUnset: { $0._storage._defaultNestedEnum == nil }),
+    .singularEnum({ $0.defaultForeignEnum }, fieldNumber: 82, isUnset: { $0._storage._defaultForeignEnum == nil }),
+    .singularEnum({ $0.defaultImportEnum }, fieldNumber: 83, isUnset: { $0._storage._defaultImportEnum == nil }),
+    .singularString({ $0.defaultStringPiece }, fieldNumber: 84, isUnset: { $0._storage._defaultStringPiece == nil }),
+    .singularString({ $0.defaultCord }, fieldNumber: 85, isUnset: { $0._storage._defaultCord == nil }),
+    .oneOf({ $0.oneofField }) {
+      switch $0 {
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofNestedMessage:
+        return _oneOfField_oneofNestedMessage
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
       }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+    },
+  ]
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_TestAllRequiredTypes, rhs: SwiftProtoTesting_TestAllRequiredTypes) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -1290,16 +1189,10 @@ extension SwiftProtoTesting_TestAllRequiredTypes.NestedMessage: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._bb {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bb }, fieldNumber: 1, isUnset: { $0._bb == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage, rhs: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage) -> Bool {
     if lhs._bb != rhs._bb {return false}
@@ -1331,16 +1224,10 @@ extension SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 17)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 17, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup, rhs: SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -1387,31 +1274,15 @@ extension SwiftProtoTesting_TestSomeRequiredTypes: SwiftProtobuf.Message, SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._requiredInt32 {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._requiredFloat {
-      try visitor.visitSingularFloatField(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._requiredBool {
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._requiredString {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 4)
-    } }()
-    try { if let v = self._requiredBytes {
-      try visitor.visitSingularBytesField(value: v, fieldNumber: 5)
-    } }()
-    try { if let v = self._requiredNestedEnum {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 6)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.requiredInt32 }, fieldNumber: 1, isUnset: { $0._requiredInt32 == nil }),
+    .singularFloat({ $0.requiredFloat }, fieldNumber: 2, isUnset: { $0._requiredFloat == nil }),
+    .singularBool({ $0.requiredBool }, fieldNumber: 3, isUnset: { $0._requiredBool == nil }),
+    .singularString({ $0.requiredString }, fieldNumber: 4, isUnset: { $0._requiredString == nil }),
+    .singularBytes({ $0.requiredBytes }, fieldNumber: 5, isUnset: { $0._requiredBytes == nil }),
+    .singularEnum({ $0.requiredNestedEnum }, fieldNumber: 6, isUnset: { $0._requiredNestedEnum == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestSomeRequiredTypes, rhs: SwiftProtoTesting_TestSomeRequiredTypes) -> Bool {
     if lhs._requiredInt32 != rhs._requiredInt32 {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift
index 5f0e57edd..07ae8a42e 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift
@@ -218,24 +218,12 @@ extension SwiftProtoTesting_CycleFoo: SwiftProtobuf.Message, SwiftProtobuf._Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._aFoo {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._aBar {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._aBaz {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.aFoo }, fieldNumber: 1, isUnset: { $0._storage._aFoo == nil }),
+    .singularMessage({ $0.aBar }, fieldNumber: 2, isUnset: { $0._storage._aBar == nil }),
+    .singularMessage({ $0.aBaz }, fieldNumber: 3, isUnset: { $0._storage._aBaz == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_CycleFoo, rhs: SwiftProtoTesting_CycleFoo) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -302,24 +290,12 @@ extension SwiftProtoTesting_CycleBar: SwiftProtobuf.Message, SwiftProtobuf._Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._aBar {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._aBaz {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._aFoo {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.aBar }, fieldNumber: 1, isUnset: { $0._storage._aBar == nil }),
+    .singularMessage({ $0.aBaz }, fieldNumber: 2, isUnset: { $0._storage._aBaz == nil }),
+    .singularMessage({ $0.aFoo }, fieldNumber: 3, isUnset: { $0._storage._aFoo == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_CycleBar, rhs: SwiftProtoTesting_CycleBar) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -386,24 +362,12 @@ extension SwiftProtoTesting_CycleBaz: SwiftProtobuf.Message, SwiftProtobuf._Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._aBaz {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._aFoo {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._aBar {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.aBaz }, fieldNumber: 1, isUnset: { $0._storage._aBaz == nil }),
+    .singularMessage({ $0.aFoo }, fieldNumber: 2, isUnset: { $0._storage._aFoo == nil }),
+    .singularMessage({ $0.aBar }, fieldNumber: 3, isUnset: { $0._storage._aBar == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_CycleBaz, rhs: SwiftProtoTesting_CycleBaz) -> Bool {
     if lhs._storage !== rhs._storage {
diff --git a/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift
index 2f7885163..16cd00354 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift
@@ -499,28 +499,14 @@ extension SwiftProtoTesting_Deprecated_MyMsg: SwiftProtobuf.Message, SwiftProtob
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._stringField {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._intField {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-      } }()
-      if !_storage._fixedField.isEmpty {
-        try visitor.visitRepeatedFixed32Field(value: _storage._fixedField, fieldNumber: 3)
-      }
-      try { if let v = _storage._msgField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
-      } }()
-      try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularString({ $0.stringField }, fieldNumber: 1, isUnset: { $0._storage._stringField == nil }),
+    .singularInt32({ $0.intField }, fieldNumber: 2, isUnset: { $0._storage._intField == nil }),
+    .repeatedFixed32({ $0.fixedField }, fieldNumber: 3),
+    .singularMessage({ $0.msgField }, fieldNumber: 4, isUnset: { $0._storage._msgField == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 100, end: 536870912),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Deprecated_MyMsg, rhs: SwiftProtoTesting_Deprecated_MyMsg) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -550,9 +536,9 @@ extension SwiftProtoTesting_Deprecated_MsgScope: SwiftProtobuf.Message, SwiftPro
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Deprecated_MsgScope, rhs: SwiftProtoTesting_Deprecated_MsgScope) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -620,27 +606,13 @@ extension SwiftProtoTesting_Deprecated_MyMsg2: SwiftProtobuf.Message, SwiftProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._stringField {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._intField {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-      } }()
-      if !_storage._fixedField.isEmpty {
-        try visitor.visitRepeatedFixed32Field(value: _storage._fixedField, fieldNumber: 3)
-      }
-      try { if let v = _storage._msgField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularString({ $0.stringField }, fieldNumber: 1, isUnset: { $0._storage._stringField == nil }),
+    .singularInt32({ $0.intField }, fieldNumber: 2, isUnset: { $0._storage._intField == nil }),
+    .repeatedFixed32({ $0.fixedField }, fieldNumber: 3),
+    .singularMessage({ $0.msgField }, fieldNumber: 4, isUnset: { $0._storage._msgField == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Deprecated_MyMsg2, rhs: SwiftProtoTesting_Deprecated_MyMsg2) -> Bool {
     if lhs._storage !== rhs._storage {
diff --git a/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.pb.swift
index 2293bc61c..0cad0579f 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.pb.swift
@@ -341,17 +341,11 @@ extension SwiftProtoTesting_DeprecatedFile_MyMsg: SwiftProtobuf.Message, SwiftPr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._stringField {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularString({ $0.stringField }, fieldNumber: 1, isUnset: { $0._stringField == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 100, end: 536870912),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_DeprecatedFile_MyMsg, rhs: SwiftProtoTesting_DeprecatedFile_MyMsg) -> Bool {
     if lhs._stringField != rhs._stringField {return false}
@@ -370,9 +364,9 @@ extension SwiftProtoTesting_DeprecatedFile_MsgScope: SwiftProtobuf.Message, Swif
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_DeprecatedFile_MsgScope, rhs: SwiftProtoTesting_DeprecatedFile_MsgScope) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift
index cbe96f5c0..79c627921 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift
@@ -158,9 +158,9 @@ extension SwiftProtoTesting_Extend_EnumOptionalDefault: SwiftProtobuf.Message, S
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_EnumOptionalDefault, rhs: SwiftProtoTesting_Extend_EnumOptionalDefault) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -212,21 +212,11 @@ extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage: SwiftProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._message {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._optionalEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 17)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.message }, fieldNumber: 1, isUnset: { $0._storage._message == nil }),
+    .singularEnum({ $0.optionalEnum }, fieldNumber: 17, isUnset: { $0._storage._optionalEnum == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage, rhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -268,16 +258,10 @@ extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2: SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._optionalEnum {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 17)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularEnum({ $0.optionalEnum }, fieldNumber: 17, isUnset: { $0._optionalEnum == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2, rhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2) -> Bool {
     if lhs._optionalEnum != rhs._optionalEnum {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.pb.swift
index 3d0e5084a..aeabf8ee9 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.pb.swift
@@ -245,21 +245,13 @@ extension SwiftProtoTesting_Enum2_SwiftEnumTest: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.values1.isEmpty {
-      try visitor.visitRepeatedEnumField(value: self.values1, fieldNumber: 1)
-    }
-    if !self.values2.isEmpty {
-      try visitor.visitRepeatedEnumField(value: self.values2, fieldNumber: 2)
-    }
-    if !self.values3.isEmpty {
-      try visitor.visitRepeatedEnumField(value: self.values3, fieldNumber: 3)
-    }
-    if !self.values4.isEmpty {
-      try visitor.visitRepeatedEnumField(value: self.values4, fieldNumber: 4)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .repeatedEnum({ $0.values1 }, fieldNumber: 1),
+    .repeatedEnum({ $0.values2 }, fieldNumber: 2),
+    .repeatedEnum({ $0.values3 }, fieldNumber: 3),
+    .repeatedEnum({ $0.values4 }, fieldNumber: 4),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Enum2_SwiftEnumTest, rhs: SwiftProtoTesting_Enum2_SwiftEnumTest) -> Bool {
     if lhs.values1 != rhs.values1 {return false}
@@ -317,12 +309,10 @@ extension SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.values.isEmpty {
-      try visitor.visitPackedEnumField(value: self.values, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .packedEnum({ $0.values }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest, rhs: SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest) -> Bool {
     if lhs.values != rhs.values {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift
index 07e323723..798293447 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift
@@ -286,21 +286,13 @@ extension SwiftProtoTesting_Enum3_SwiftEnumTest: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.values1.isEmpty {
-      try visitor.visitPackedEnumField(value: self.values1, fieldNumber: 1)
-    }
-    if !self.values2.isEmpty {
-      try visitor.visitPackedEnumField(value: self.values2, fieldNumber: 2)
-    }
-    if !self.values3.isEmpty {
-      try visitor.visitPackedEnumField(value: self.values3, fieldNumber: 3)
-    }
-    if !self.values4.isEmpty {
-      try visitor.visitPackedEnumField(value: self.values4, fieldNumber: 4)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .packedEnum({ $0.values1 }, fieldNumber: 1),
+    .packedEnum({ $0.values2 }, fieldNumber: 2),
+    .packedEnum({ $0.values3 }, fieldNumber: 3),
+    .packedEnum({ $0.values4 }, fieldNumber: 4),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Enum3_SwiftEnumTest, rhs: SwiftProtoTesting_Enum3_SwiftEnumTest) -> Bool {
     if lhs.values1 != rhs.values1 {return false}
@@ -358,12 +350,10 @@ extension SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.values.isEmpty {
-      try visitor.visitPackedEnumField(value: self.values, fieldNumber: 1)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .packedEnum({ $0.values }, fieldNumber: 1),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest, rhs: SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest) -> Bool {
     if lhs.values != rhs.values {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift
index dc9301b71..c4cd547aa 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift
@@ -418,9 +418,9 @@ extension SwiftProtoTesting_Extend_Foo: SwiftProtobuf.Message, SwiftProtobuf._Me
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_Foo, rhs: SwiftProtoTesting_Extend_Foo) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -437,9 +437,9 @@ extension SwiftProtoTesting_Extend_Foo.Bar: SwiftProtobuf.Message, SwiftProtobuf
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_Foo.Bar, rhs: SwiftProtoTesting_Extend_Foo.Bar) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -472,17 +472,11 @@ extension SwiftProtoTesting_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 1001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._a == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 100, end: 1001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_Foo.Bar.Baz, rhs: SwiftProtoTesting_Extend_Foo.Bar.Baz) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -510,16 +504,10 @@ extension SwiftProtoTesting_Extend_C: SwiftProtobuf.Message, SwiftProtobuf._Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._c {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 999)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.c }, fieldNumber: 999, isUnset: { $0._c == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_C, rhs: SwiftProtoTesting_Extend_C) -> Bool {
     if lhs._c != rhs._c {return false}
@@ -545,10 +533,10 @@ extension SwiftProtoTesting_Extend_Msg1: SwiftProtobuf.Message, SwiftProtobuf._M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 1001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1, end: 1001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_Msg1, rhs: SwiftProtoTesting_Extend_Msg1) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -574,10 +562,10 @@ extension SwiftProtoTesting_Extend_Msg2: SwiftProtobuf.Message, SwiftProtobuf._M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 1001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1, end: 1001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_Msg2, rhs: SwiftProtoTesting_Extend_Msg2) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -611,17 +599,11 @@ extension SwiftProtoTesting_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._x {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 201)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.x }, fieldNumber: 1, isUnset: { $0._x == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 100, end: 201),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_MsgNoStorage, rhs: SwiftProtoTesting_Extend_MsgNoStorage) -> Bool {
     if lhs._x != rhs._x {return false}
@@ -685,22 +667,12 @@ extension SwiftProtoTesting_Extend_MsgUsesStorage: SwiftProtobuf.Message, SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._x {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._y {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-      try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 201)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.x }, fieldNumber: 1, isUnset: { $0._storage._x == nil }),
+    .singularMessage({ $0.y }, fieldNumber: 2, isUnset: { $0._storage._y == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 100, end: 201),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend_MsgUsesStorage, rhs: SwiftProtoTesting_Extend_MsgUsesStorage) -> Bool {
     if lhs._storage !== rhs._storage {
diff --git a/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift
index b05ac66f9..37dfd3ece 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift
@@ -217,9 +217,9 @@ extension SwiftProtoTesting_Extend2_MyMessage: SwiftProtobuf.Message, SwiftProto
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend2_MyMessage, rhs: SwiftProtoTesting_Extend2_MyMessage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -245,16 +245,10 @@ extension SwiftProtoTesting_Extend2_MyMessage.C: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._c {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 1210)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.c }, fieldNumber: 1210, isUnset: { $0._c == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend2_MyMessage.C, rhs: SwiftProtoTesting_Extend2_MyMessage.C) -> Bool {
     if lhs._c != rhs._c {return false}
@@ -281,16 +275,10 @@ extension SwiftProtoTesting_Extend2_C: SwiftProtobuf.Message, SwiftProtobuf._Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._c {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 1220)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.c }, fieldNumber: 1220, isUnset: { $0._c == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend2_C, rhs: SwiftProtoTesting_Extend2_C) -> Bool {
     if lhs._c != rhs._c {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift
index 29e965d11..20a87d2d8 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift
@@ -217,9 +217,9 @@ extension SwiftProtoTesting_Extend3_MyMessage: SwiftProtobuf.Message, SwiftProto
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend3_MyMessage, rhs: SwiftProtoTesting_Extend3_MyMessage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -245,16 +245,10 @@ extension SwiftProtoTesting_Extend3_MyMessage.C: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._c {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 1310)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.c }, fieldNumber: 1310, isUnset: { $0._c == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend3_MyMessage.C, rhs: SwiftProtoTesting_Extend3_MyMessage.C) -> Bool {
     if lhs._c != rhs._c {return false}
@@ -281,16 +275,10 @@ extension SwiftProtoTesting_Extend3_C: SwiftProtobuf.Message, SwiftProtobuf._Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._c {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 1320)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.c }, fieldNumber: 1320, isUnset: { $0._c == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Extend3_C, rhs: SwiftProtoTesting_Extend3_C) -> Bool {
     if lhs._c != rhs._c {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift
index 2a784fb10..9186fa930 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift
@@ -217,9 +217,9 @@ extension Ext4MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementa
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: Ext4MyMessage, rhs: Ext4MyMessage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -245,16 +245,10 @@ extension Ext4MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplemen
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._c {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 1410)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.c }, fieldNumber: 1410, isUnset: { $0._c == nil }),
+  ]
+
 
   static func ==(lhs: Ext4MyMessage.C, rhs: Ext4MyMessage.C) -> Bool {
     if lhs._c != rhs._c {return false}
@@ -281,16 +275,10 @@ extension Ext4C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._c {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 1420)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.c }, fieldNumber: 1420, isUnset: { $0._c == nil }),
+  ]
+
 
   static func ==(lhs: Ext4C, rhs: Ext4C) -> Bool {
     if lhs._c != rhs._c {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift
index ab4754d5f..3b788ce69 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift
@@ -429,44 +429,45 @@ extension SwiftProtoTesting_Order_TestFieldOrderings: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._myInt {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 1)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 9)
-    switch self.options {
-    case .oneofBool?: try {
-      guard case .oneofBool(let v)? = self.options else { preconditionFailure() }
-      try visitor.visitSingularBoolField(value: v, fieldNumber: 9)
-    }()
-    case .oneofInt32?: try {
-      guard case .oneofInt32(let v)? = self.options else { preconditionFailure() }
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 10)
-    }()
-    default: break
-    }
-    try { if let v = self._myString {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 11)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 12, end: 56)
-    try { if case .oneofInt64(let v)? = self.options {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 60)
-    } }()
-    try { if let v = self._myFloat {
-      try visitor.visitSingularFloatField(value: v, fieldNumber: 101)
-    } }()
-    try { if case .oneofString(let v)? = self.options {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 150)
-    } }()
-    try { if let v = self._optionalNestedMessage {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 200)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt64({ $0.myInt }, fieldNumber: 1, isUnset: { $0._myInt == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 2, end: 9),
+    .oneOf({ $0.options }) {
+      switch $0 {
+      case .oneofBool:
+        return _oneOfField_oneofBool
+      case .oneofInt32:
+        return _oneOfField_oneofInt32
+      default:
+        return nil
+      }
+    },
+    .singularString({ $0.myString }, fieldNumber: 11, isUnset: { $0._myString == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 12, end: 56),
+    .oneOf({ $0.options }) {
+      switch $0 {
+      case .oneofInt64:
+        return _oneOfField_oneofInt64
+      default:
+        return nil
+      }
+    },
+    .singularFloat({ $0.myFloat }, fieldNumber: 101, isUnset: { $0._myFloat == nil }),
+    .oneOf({ $0.options }) {
+      switch $0 {
+      case .oneofString:
+        return _oneOfField_oneofString
+      default:
+        return nil
+      }
+    },
+    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 200, isUnset: { $0._optionalNestedMessage == nil }),
+  ]
+  private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 9, isUnset: { _ in false })
+  private static let _oneOfField_oneofInt32: Field<Self> = .singularInt32({ $0.oneofInt32 }, fieldNumber: 10, isUnset: { _ in false })
+  private static let _oneOfField_oneofInt64: Field<Self> = .singularInt64({ $0.oneofInt64 }, fieldNumber: 60, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 150, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Order_TestFieldOrderings, rhs: SwiftProtoTesting_Order_TestFieldOrderings) -> Bool {
     if lhs._myString != rhs._myString {return false}
@@ -500,19 +501,11 @@ extension SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage: SwiftProtobu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._bb {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._oo {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bb }, fieldNumber: 1, isUnset: { $0._bb == nil }),
+    .singularInt64({ $0.oo }, fieldNumber: 2, isUnset: { $0._oo == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage, rhs: SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage) -> Bool {
     if lhs._oo != rhs._oo {return false}
@@ -619,47 +612,76 @@ extension SwiftProtoTesting_Order_OneofTraversalGeneration: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    switch self.oGood {
-    case .a?: try {
-      guard case .a(let v)? = self.oGood else { preconditionFailure() }
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    }()
-    case .b?: try {
-      guard case .b(let v)? = self.oGood else { preconditionFailure() }
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 26)
-    }()
-    case nil: break
-    }
-    try { if case .a2(let v)? = self.oConflictField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 101)
-    } }()
-    try { if let v = self._m {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 113)
-    } }()
-    try { if case .b2(let v)? = self.oConflictField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 126)
-    } }()
-    try { if case .a3(let v)? = self.oConflictExtensionsStart {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 201)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 202, end: 203)
-    try { if case .b3(let v)? = self.oConflictExtensionsStart {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 226)
-    } }()
-    try { if case .a4(let v)? = self.oConflictExtensionsEnd {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 301)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 325, end: 326)
-    try { if case .b4(let v)? = self.oConflictExtensionsEnd {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 326)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .oneOf({ $0.oGood }) {
+      switch $0 {
+      case .a:
+        return _oneOfField_a
+      case .b:
+        return _oneOfField_b
+      }
+    },
+    .oneOf({ $0.oConflictField }) {
+      switch $0 {
+      case .a2:
+        return _oneOfField_a2
+      default:
+        return nil
+      }
+    },
+    .singularInt32({ $0.m }, fieldNumber: 113, isUnset: { $0._m == nil }),
+    .oneOf({ $0.oConflictField }) {
+      switch $0 {
+      case .b2:
+        return _oneOfField_b2
+      default:
+        return nil
+      }
+    },
+    .oneOf({ $0.oConflictExtensionsStart }) {
+      switch $0 {
+      case .a3:
+        return _oneOfField_a3
+      default:
+        return nil
+      }
+    },
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 202, end: 203),
+    .oneOf({ $0.oConflictExtensionsStart }) {
+      switch $0 {
+      case .b3:
+        return _oneOfField_b3
+      default:
+        return nil
+      }
+    },
+    .oneOf({ $0.oConflictExtensionsEnd }) {
+      switch $0 {
+      case .a4:
+        return _oneOfField_a4
+      default:
+        return nil
+      }
+    },
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 325, end: 326),
+    .oneOf({ $0.oConflictExtensionsEnd }) {
+      switch $0 {
+      case .b4:
+        return _oneOfField_b4
+      default:
+        return nil
+      }
+    },
+  ]
+  private static let _oneOfField_a: Field<Self> = .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { _ in false })
+  private static let _oneOfField_b: Field<Self> = .singularInt32({ $0.b }, fieldNumber: 26, isUnset: { _ in false })
+  private static let _oneOfField_a2: Field<Self> = .singularInt32({ $0.a2 }, fieldNumber: 101, isUnset: { _ in false })
+  private static let _oneOfField_b2: Field<Self> = .singularInt32({ $0.b2 }, fieldNumber: 126, isUnset: { _ in false })
+  private static let _oneOfField_a3: Field<Self> = .singularInt32({ $0.a3 }, fieldNumber: 201, isUnset: { _ in false })
+  private static let _oneOfField_b3: Field<Self> = .singularInt32({ $0.b3 }, fieldNumber: 226, isUnset: { _ in false })
+  private static let _oneOfField_a4: Field<Self> = .singularInt32({ $0.a4 }, fieldNumber: 301, isUnset: { _ in false })
+  private static let _oneOfField_b4: Field<Self> = .singularInt32({ $0.b4 }, fieldNumber: 326, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Order_OneofTraversalGeneration, rhs: SwiftProtoTesting_Order_OneofTraversalGeneration) -> Bool {
     if lhs.oGood != rhs.oGood {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift
index af11ff9f8..9346b084f 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift
@@ -350,17 +350,11 @@ extension SwiftTestGroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 11)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._a == nil }),
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 2, end: 11),
+  ]
+
 
   static func ==(lhs: SwiftTestGroupExtensions, rhs: SwiftTestGroupExtensions) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -388,16 +382,10 @@ extension ExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: ExtensionGroup, rhs: ExtensionGroup) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -424,16 +412,10 @@ extension RepeatedExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageI
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: RepeatedExtensionGroup, rhs: RepeatedExtensionGroup) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -460,16 +442,10 @@ extension SwiftTestGroupUnextended: SwiftProtobuf.Message, SwiftProtobuf._Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: SwiftTestGroupUnextended, rhs: SwiftTestGroupUnextended) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -500,22 +476,12 @@ extension SwiftTestNestingGroupsMessage: SwiftProtobuf.Message, SwiftProtobuf._M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._outerA {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._subGroup1 {
-      try visitor.visitSingularGroupField(value: v, fieldNumber: 2)
-    } }()
-    if !self.subGroup3.isEmpty {
-      try visitor.visitRepeatedGroupField(value: self.subGroup3, fieldNumber: 3)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.outerA }, fieldNumber: 1, isUnset: { $0._outerA == nil }),
+    .singularGroup({ $0.subGroup1 }, fieldNumber: 2, isUnset: { $0._subGroup1 == nil }),
+    .repeatedGroup({ $0.subGroup3 }, fieldNumber: 3),
+  ]
+
 
   static func ==(lhs: SwiftTestNestingGroupsMessage, rhs: SwiftTestNestingGroupsMessage) -> Bool {
     if lhs._outerA != rhs._outerA {return false}
@@ -546,19 +512,11 @@ extension SwiftTestNestingGroupsMessage.SubGroup1: SwiftProtobuf.Message, SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._sub1A {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._subGroup2 {
-      try visitor.visitSingularGroupField(value: v, fieldNumber: 2)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sub1A }, fieldNumber: 1, isUnset: { $0._sub1A == nil }),
+    .singularGroup({ $0.subGroup2 }, fieldNumber: 2, isUnset: { $0._subGroup2 == nil }),
+  ]
+
 
   static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup1, rhs: SwiftTestNestingGroupsMessage.SubGroup1) -> Bool {
     if lhs._sub1A != rhs._sub1A {return false}
@@ -586,16 +544,10 @@ extension SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._sub2A {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sub2A }, fieldNumber: 1, isUnset: { $0._sub2A == nil }),
+  ]
+
 
   static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2, rhs: SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2) -> Bool {
     if lhs._sub2A != rhs._sub2A {return false}
@@ -624,19 +576,11 @@ extension SwiftTestNestingGroupsMessage.SubGroup3: SwiftProtobuf.Message, SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._sub3A {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    if !self.subGroup4.isEmpty {
-      try visitor.visitRepeatedGroupField(value: self.subGroup4, fieldNumber: 2)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sub3A }, fieldNumber: 1, isUnset: { $0._sub3A == nil }),
+    .repeatedGroup({ $0.subGroup4 }, fieldNumber: 2),
+  ]
+
 
   static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup3, rhs: SwiftTestNestingGroupsMessage.SubGroup3) -> Bool {
     if lhs._sub3A != rhs._sub3A {return false}
@@ -664,16 +608,10 @@ extension SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._sub4A {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sub4A }, fieldNumber: 1, isUnset: { $0._sub4A == nil }),
+  ]
+
 
   static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4, rhs: SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4) -> Bool {
     if lhs._sub4A != rhs._sub4A {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift
index 4e0858e96..905c0b09e 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift
@@ -64,12 +64,10 @@ extension SwiftProtoTesting_SwiftJSONTest: SwiftProtobuf.Message, SwiftProtobuf.
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.repeatedNullValue.isEmpty {
-      try visitor.visitPackedEnumField(value: self.repeatedNullValue, fieldNumber: 318)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .packedEnum({ $0.repeatedNullValue }, fieldNumber: 318),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_SwiftJSONTest, rhs: SwiftProtoTesting_SwiftJSONTest) -> Bool {
     if lhs.repeatedNullValue != rhs.repeatedNullValue {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift
index 64895f7ab..7cc6e12de 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift
@@ -15383,10 +15383,10 @@ extension SwiftProtoTesting_Names_Foo: SwiftProtobuf.Message, SwiftProtobuf._Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 5001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1, end: 5001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_Foo, rhs: SwiftProtoTesting_Names_Foo) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -16319,681 +16319,231 @@ extension SwiftProtoTesting_Names_FieldNames: SwiftProtobuf.Message, SwiftProtob
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._string {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._int {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._double {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._float {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._uint {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._hashValue_p {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._description_p {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._debugDescription_p {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._swift {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._unrecognized {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._class {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._deinit {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._enum {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._func {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._import {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._init_p {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 17)
-      } }()
-      try { if let v = _storage._inout {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._internal {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 19)
-      } }()
-      try { if let v = _storage._let {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 20)
-      } }()
-      try { if let v = _storage._operator {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 21)
-      } }()
-      try { if let v = _storage._private {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 22)
-      } }()
-      try { if let v = _storage._protocol {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 23)
-      } }()
-      try { if let v = _storage._public {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 24)
-      } }()
-      try { if let v = _storage._static {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 25)
-      } }()
-      try { if let v = _storage._struct {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 26)
-      } }()
-      try { if let v = _storage._subscript {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 27)
-      } }()
-      try { if let v = _storage._typealias {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 28)
-      } }()
-      try { if let v = _storage._var {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 29)
-      } }()
-      try { if let v = _storage._break {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 30)
-      } }()
-      try { if let v = _storage._case {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 31)
-      } }()
-      try { if let v = _storage._continue {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 32)
-      } }()
-      try { if let v = _storage._default {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 33)
-      } }()
-      try { if let v = _storage._defer {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 34)
-      } }()
-      try { if let v = _storage._do {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 35)
-      } }()
-      try { if let v = _storage._else {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 36)
-      } }()
-      try { if let v = _storage._fallthrough {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 37)
-      } }()
-      try { if let v = _storage._for {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 38)
-      } }()
-      try { if let v = _storage._guard {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 39)
-      } }()
-      try { if let v = _storage._if {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 40)
-      } }()
-      try { if let v = _storage._in {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 41)
-      } }()
-      try { if let v = _storage._repeat {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 42)
-      } }()
-      try { if let v = _storage._return {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 43)
-      } }()
-      try { if let v = _storage._switch {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 44)
-      } }()
-      try { if let v = _storage._where {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 45)
-      } }()
-      try { if let v = _storage._while {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 46)
-      } }()
-      try { if let v = _storage._as {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 47)
-      } }()
-      try { if let v = _storage._catch {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 48)
-      } }()
-      try { if let v = _storage._dynamicType_p {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 49)
-      } }()
-      try { if let v = _storage._false {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 50)
-      } }()
-      try { if let v = _storage._is {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 51)
-      } }()
-      try { if let v = _storage._nil {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 52)
-      } }()
-      try { if let v = _storage._rethrows {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 53)
-      } }()
-      try { if let v = _storage._super {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 54)
-      } }()
-      try { if let v = _storage._self_p {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 55)
-      } }()
-      try { if let v = _storage._throw {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 57)
-      } }()
-      try { if let v = _storage._throws {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 58)
-      } }()
-      try { if let v = _storage._true {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 59)
-      } }()
-      try { if let v = _storage._try {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 60)
-      } }()
-      try { if let v = _storage.__Column__ {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 61)
-      } }()
-      try { if let v = _storage.__File__ {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 62)
-      } }()
-      try { if let v = _storage.__Function__ {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 63)
-      } }()
-      try { if let v = _storage.__Line__ {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 64)
-      } }()
-      try { if let v = _storage.____ {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 65)
-      } }()
-      try { if let v = _storage._associativity {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 66)
-      } }()
-      try { if let v = _storage._convenience {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 67)
-      } }()
-      try { if let v = _storage._dynamic {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 68)
-      } }()
-      try { if let v = _storage._didSet {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 69)
-      } }()
-      try { if let v = _storage._final {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 70)
-      } }()
-      try { if let v = _storage._get {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 71)
-      } }()
-      try { if let v = _storage._infix {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 72)
-      } }()
-      try { if let v = _storage._indirect {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 73)
-      } }()
-      try { if let v = _storage._lazy {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 74)
-      } }()
-      try { if let v = _storage._left {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 75)
-      } }()
-      try { if let v = _storage._mutating {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 76)
-      } }()
-      try { if let v = _storage._none {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 77)
-      } }()
-      try { if let v = _storage._nonmutating {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 78)
-      } }()
-      try { if let v = _storage._optional {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 79)
-      } }()
-      try { if let v = _storage._override {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 80)
-      } }()
-      try { if let v = _storage._postfix {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 81)
-      } }()
-      try { if let v = _storage._precedence {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 82)
-      } }()
-      try { if let v = _storage._prefix {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 83)
-      } }()
-      try { if let v = _storage._required {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 85)
-      } }()
-      try { if let v = _storage._right {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 86)
-      } }()
-      try { if let v = _storage._set {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 87)
-      } }()
-      try { if let v = _storage._type {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 88)
-      } }()
-      try { if let v = _storage._unowned {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 89)
-      } }()
-      try { if let v = _storage._weak {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 90)
-      } }()
-      try { if let v = _storage._willSet {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 91)
-      } }()
-      try { if let v = _storage._id {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 92)
-      } }()
-      try { if let v = _storage._cmd {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 93)
-      } }()
-      try { if let v = _storage._out {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 96)
-      } }()
-      try { if let v = _storage._bycopy {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 98)
-      } }()
-      try { if let v = _storage._byref {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 99)
-      } }()
-      try { if let v = _storage._oneway {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 100)
-      } }()
-      try { if let v = _storage._and {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 102)
-      } }()
-      try { if let v = _storage._andEq {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 103)
-      } }()
-      try { if let v = _storage._alignas {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 104)
-      } }()
-      try { if let v = _storage._alignof {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 105)
-      } }()
-      try { if let v = _storage._asm {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 106)
-      } }()
-      try { if let v = _storage._auto {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 107)
-      } }()
-      try { if let v = _storage._bitand {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 108)
-      } }()
-      try { if let v = _storage._bitor {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 109)
-      } }()
-      try { if let v = _storage._bool {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 110)
-      } }()
-      try { if let v = _storage._char {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 114)
-      } }()
-      try { if let v = _storage._char16T {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 115)
-      } }()
-      try { if let v = _storage._char32T {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 116)
-      } }()
-      try { if let v = _storage._compl {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 118)
-      } }()
-      try { if let v = _storage._const {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 119)
-      } }()
-      try { if let v = _storage._constexpr {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 120)
-      } }()
-      try { if let v = _storage._constCast {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 121)
-      } }()
-      try { if let v = _storage._decltype {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 123)
-      } }()
-      try { if let v = _storage._delete {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 125)
-      } }()
-      try { if let v = _storage._dynamicCast {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 127)
-      } }()
-      try { if let v = _storage._explicit {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 130)
-      } }()
-      try { if let v = _storage._export {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 131)
-      } }()
-      try { if let v = _storage._extern {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 132)
-      } }()
-      try { if let v = _storage._friend {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 136)
-      } }()
-      try { if let v = _storage._goto {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 137)
-      } }()
-      try { if let v = _storage._inline {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 139)
-      } }()
-      try { if let v = _storage._long {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 141)
-      } }()
-      try { if let v = _storage._mutable {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 142)
-      } }()
-      try { if let v = _storage._namespace {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 143)
-      } }()
-      try { if let v = _storage._new {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 144)
-      } }()
-      try { if let v = _storage._noexcept {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 145)
-      } }()
-      try { if let v = _storage._not {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 146)
-      } }()
-      try { if let v = _storage._notEq {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 147)
-      } }()
-      try { if let v = _storage._nullptr {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 148)
-      } }()
-      try { if let v = _storage._or {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 150)
-      } }()
-      try { if let v = _storage._orEq {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 151)
-      } }()
-      try { if let v = _storage._protected {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 153)
-      } }()
-      try { if let v = _storage._register {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 155)
-      } }()
-      try { if let v = _storage._reinterpretCast {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 156)
-      } }()
-      try { if let v = _storage._short {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 158)
-      } }()
-      try { if let v = _storage._signed {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 159)
-      } }()
-      try { if let v = _storage._sizeof {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 160)
-      } }()
-      try { if let v = _storage._staticAssert {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 162)
-      } }()
-      try { if let v = _storage._staticCast {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 163)
-      } }()
-      try { if let v = _storage._template {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 166)
-      } }()
-      try { if let v = _storage._this {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 167)
-      } }()
-      try { if let v = _storage._threadLocal {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 168)
-      } }()
-      try { if let v = _storage._typedef {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 172)
-      } }()
-      try { if let v = _storage._typeid {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 173)
-      } }()
-      try { if let v = _storage._typename {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 174)
-      } }()
-      try { if let v = _storage._union {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 175)
-      } }()
-      try { if let v = _storage._unsigned {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 176)
-      } }()
-      try { if let v = _storage._using {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 177)
-      } }()
-      try { if let v = _storage._virtual {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 178)
-      } }()
-      try { if let v = _storage._void {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 179)
-      } }()
-      try { if let v = _storage._volatile {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 180)
-      } }()
-      try { if let v = _storage._wcharT {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 181)
-      } }()
-      try { if let v = _storage._xor {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 183)
-      } }()
-      try { if let v = _storage._xorEq {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 184)
-      } }()
-      try { if let v = _storage._restrict {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 185)
-      } }()
-      try { if let v = _storage._category {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 186)
-      } }()
-      try { if let v = _storage._ivar {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 187)
-      } }()
-      try { if let v = _storage._method {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 188)
-      } }()
-      try { if let v = _storage._finalize {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 192)
-      } }()
-      try { if let v = _storage._hash {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 193)
-      } }()
-      try { if let v = _storage._dealloc {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 194)
-      } }()
-      try { if let v = _storage._superclass {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 197)
-      } }()
-      try { if let v = _storage._retain {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 198)
-      } }()
-      try { if let v = _storage._release {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 199)
-      } }()
-      try { if let v = _storage._autorelease {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 200)
-      } }()
-      try { if let v = _storage._retainCount {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 201)
-      } }()
-      try { if let v = _storage._zone {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 202)
-      } }()
-      try { if let v = _storage._isProxy {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 203)
-      } }()
-      try { if let v = _storage._copy {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 204)
-      } }()
-      try { if let v = _storage._mutableCopy {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 205)
-      } }()
-      try { if let v = _storage._classForCoder {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 206)
-      } }()
-      try { if let v = _storage._clear {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 207)
-      } }()
-      try { if let v = _storage._data {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 208)
-      } }()
-      try { if let v = _storage._delimitedData {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 209)
-      } }()
-      try { if let v = _storage._descriptor {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 210)
-      } }()
-      try { if let v = _storage._extensionRegistry {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 211)
-      } }()
-      try { if let v = _storage._extensionsCurrentlySet {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 212)
-      } }()
-      try { if let v = _storage._isInitialized_p {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 213)
-      } }()
-      try { if let v = _storage._serializedSize {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 214)
-      } }()
-      try { if let v = _storage._sortedExtensionsInUse {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 215)
-      } }()
-      try { if let v = _storage._unknownFields_p {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 216)
-      } }()
-      try { if let v = _storage._fixed {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 217)
-      } }()
-      try { if let v = _storage._fract {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 218)
-      } }()
-      try { if let v = _storage._size {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 219)
-      } }()
-      try { if let v = _storage._logicalAddress {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 220)
-      } }()
-      try { if let v = _storage._physicalAddress {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 221)
-      } }()
-      try { if let v = _storage._byteCount {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 222)
-      } }()
-      try { if let v = _storage._byteOffset {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 223)
-      } }()
-      try { if let v = _storage._duration {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 224)
-      } }()
-      try { if let v = _storage._absoluteTime {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 225)
-      } }()
-      try { if let v = _storage._optionBits {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 226)
-      } }()
-      try { if let v = _storage._itemCount {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 227)
-      } }()
-      try { if let v = _storage._pbversion {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 228)
-      } }()
-      try { if let v = _storage._scriptCode {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 229)
-      } }()
-      try { if let v = _storage._langCode {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 230)
-      } }()
-      try { if let v = _storage._regionCode {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 231)
-      } }()
-      try { if let v = _storage._ostype {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 232)
-      } }()
-      try { if let v = _storage._processSerialNumber {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 233)
-      } }()
-      try { if let v = _storage._point {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 234)
-      } }()
-      try { if let v = _storage._rect {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 235)
-      } }()
-      try { if let v = _storage._fixedPoint {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 236)
-      } }()
-      try { if let v = _storage._fixedRect {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 237)
-      } }()
-      try { if let v = _storage._style {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 238)
-      } }()
-      try { if let v = _storage._styleParameter {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 239)
-      } }()
-      try { if let v = _storage._styleField {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 240)
-      } }()
-      try { if let v = _storage._timeScale {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 241)
-      } }()
-      try { if let v = _storage._timeBase {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 242)
-      } }()
-      try { if let v = _storage._timeRecord {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 243)
-      } }()
-      try { if let v = _storage._jsonShouldBeOverridden {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 244)
-      } }()
-      try { if let v = _storage._any {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 245)
-      } }()
-      try { if let v = _storage._int32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 246)
-      } }()
-      try { if let v = _storage._int64 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 247)
-      } }()
-      try { if let v = _storage._uint32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 250)
-      } }()
-      try { if let v = _storage._uint64 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 251)
-      } }()
-      try { if let v = _storage._associatedtype {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 252)
-      } }()
-      try { if let v = _storage._fileprivate {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 253)
-      } }()
-      try { if let v = _storage._open {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 254)
-      } }()
-      try { if let v = _storage._serializedData {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 255)
-      } }()
-      try { if let v = _storage._hasSerializedData_p {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 256)
-      } }()
-      try { if let v = _storage._clearSerializedData_p {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 257)
-      } }()
-      try { if let v = _storage._jsonUtf8Data {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 258)
-      } }()
-      try { if let v = _storage._jsonString {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 259)
-      } }()
-      try { if let v = _storage._extension {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 260)
-      } }()
-      try { if let v = _storage._extensions {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 261)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.string }, fieldNumber: 1, isUnset: { $0._storage._string == nil }),
+    .singularInt32({ $0.int }, fieldNumber: 2, isUnset: { $0._storage._int == nil }),
+    .singularInt32({ $0.double }, fieldNumber: 3, isUnset: { $0._storage._double == nil }),
+    .singularInt32({ $0.float }, fieldNumber: 4, isUnset: { $0._storage._float == nil }),
+    .singularInt32({ $0.uint }, fieldNumber: 5, isUnset: { $0._storage._uint == nil }),
+    .singularInt32({ $0.hashValue_p }, fieldNumber: 6, isUnset: { $0._storage._hashValue_p == nil }),
+    .singularInt32({ $0.description_p }, fieldNumber: 7, isUnset: { $0._storage._description_p == nil }),
+    .singularInt32({ $0.debugDescription_p }, fieldNumber: 8, isUnset: { $0._storage._debugDescription_p == nil }),
+    .singularInt32({ $0.swift }, fieldNumber: 9, isUnset: { $0._storage._swift == nil }),
+    .singularInt32({ $0.unrecognized }, fieldNumber: 10, isUnset: { $0._storage._unrecognized == nil }),
+    .singularInt32({ $0.`class` }, fieldNumber: 11, isUnset: { $0._storage._class == nil }),
+    .singularInt32({ $0.`deinit` }, fieldNumber: 12, isUnset: { $0._storage._deinit == nil }),
+    .singularInt32({ $0.`enum` }, fieldNumber: 13, isUnset: { $0._storage._enum == nil }),
+    .singularInt32({ $0.`func` }, fieldNumber: 15, isUnset: { $0._storage._func == nil }),
+    .singularInt32({ $0.`import` }, fieldNumber: 16, isUnset: { $0._storage._import == nil }),
+    .singularInt32({ $0.init_p }, fieldNumber: 17, isUnset: { $0._storage._init_p == nil }),
+    .singularInt32({ $0.`inout` }, fieldNumber: 18, isUnset: { $0._storage._inout == nil }),
+    .singularInt32({ $0.`internal` }, fieldNumber: 19, isUnset: { $0._storage._internal == nil }),
+    .singularInt32({ $0.`let` }, fieldNumber: 20, isUnset: { $0._storage._let == nil }),
+    .singularInt32({ $0.`operator` }, fieldNumber: 21, isUnset: { $0._storage._operator == nil }),
+    .singularInt32({ $0.`private` }, fieldNumber: 22, isUnset: { $0._storage._private == nil }),
+    .singularInt32({ $0.`protocol` }, fieldNumber: 23, isUnset: { $0._storage._protocol == nil }),
+    .singularInt32({ $0.`public` }, fieldNumber: 24, isUnset: { $0._storage._public == nil }),
+    .singularInt32({ $0.`static` }, fieldNumber: 25, isUnset: { $0._storage._static == nil }),
+    .singularInt32({ $0.`struct` }, fieldNumber: 26, isUnset: { $0._storage._struct == nil }),
+    .singularInt32({ $0.`subscript` }, fieldNumber: 27, isUnset: { $0._storage._subscript == nil }),
+    .singularInt32({ $0.`typealias` }, fieldNumber: 28, isUnset: { $0._storage._typealias == nil }),
+    .singularInt32({ $0.`var` }, fieldNumber: 29, isUnset: { $0._storage._var == nil }),
+    .singularInt32({ $0.`break` }, fieldNumber: 30, isUnset: { $0._storage._break == nil }),
+    .singularInt32({ $0.`case` }, fieldNumber: 31, isUnset: { $0._storage._case == nil }),
+    .singularInt32({ $0.`continue` }, fieldNumber: 32, isUnset: { $0._storage._continue == nil }),
+    .singularInt32({ $0.`default` }, fieldNumber: 33, isUnset: { $0._storage._default == nil }),
+    .singularInt32({ $0.`defer` }, fieldNumber: 34, isUnset: { $0._storage._defer == nil }),
+    .singularInt32({ $0.`do` }, fieldNumber: 35, isUnset: { $0._storage._do == nil }),
+    .singularInt32({ $0.`else` }, fieldNumber: 36, isUnset: { $0._storage._else == nil }),
+    .singularInt32({ $0.`fallthrough` }, fieldNumber: 37, isUnset: { $0._storage._fallthrough == nil }),
+    .singularInt32({ $0.`for` }, fieldNumber: 38, isUnset: { $0._storage._for == nil }),
+    .singularInt32({ $0.`guard` }, fieldNumber: 39, isUnset: { $0._storage._guard == nil }),
+    .singularInt32({ $0.`if` }, fieldNumber: 40, isUnset: { $0._storage._if == nil }),
+    .singularInt32({ $0.`in` }, fieldNumber: 41, isUnset: { $0._storage._in == nil }),
+    .singularInt32({ $0.`repeat` }, fieldNumber: 42, isUnset: { $0._storage._repeat == nil }),
+    .singularInt32({ $0.`return` }, fieldNumber: 43, isUnset: { $0._storage._return == nil }),
+    .singularInt32({ $0.`switch` }, fieldNumber: 44, isUnset: { $0._storage._switch == nil }),
+    .singularInt32({ $0.`where` }, fieldNumber: 45, isUnset: { $0._storage._where == nil }),
+    .singularInt32({ $0.`while` }, fieldNumber: 46, isUnset: { $0._storage._while == nil }),
+    .singularInt32({ $0.`as` }, fieldNumber: 47, isUnset: { $0._storage._as == nil }),
+    .singularInt32({ $0.`catch` }, fieldNumber: 48, isUnset: { $0._storage._catch == nil }),
+    .singularInt32({ $0.dynamicType_p }, fieldNumber: 49, isUnset: { $0._storage._dynamicType_p == nil }),
+    .singularInt32({ $0.`false` }, fieldNumber: 50, isUnset: { $0._storage._false == nil }),
+    .singularInt32({ $0.`is` }, fieldNumber: 51, isUnset: { $0._storage._is == nil }),
+    .singularInt32({ $0.`nil` }, fieldNumber: 52, isUnset: { $0._storage._nil == nil }),
+    .singularInt32({ $0.`rethrows` }, fieldNumber: 53, isUnset: { $0._storage._rethrows == nil }),
+    .singularInt32({ $0.`super` }, fieldNumber: 54, isUnset: { $0._storage._super == nil }),
+    .singularInt32({ $0.self_p }, fieldNumber: 55, isUnset: { $0._storage._self_p == nil }),
+    .singularInt32({ $0.`throw` }, fieldNumber: 57, isUnset: { $0._storage._throw == nil }),
+    .singularInt32({ $0.`throws` }, fieldNumber: 58, isUnset: { $0._storage._throws == nil }),
+    .singularInt32({ $0.`true` }, fieldNumber: 59, isUnset: { $0._storage._true == nil }),
+    .singularInt32({ $0.`try` }, fieldNumber: 60, isUnset: { $0._storage._try == nil }),
+    .singularInt32({ $0._Column__ }, fieldNumber: 61, isUnset: { $0._storage.__Column__ == nil }),
+    .singularInt32({ $0._File__ }, fieldNumber: 62, isUnset: { $0._storage.__File__ == nil }),
+    .singularInt32({ $0._Function__ }, fieldNumber: 63, isUnset: { $0._storage.__Function__ == nil }),
+    .singularInt32({ $0._Line__ }, fieldNumber: 64, isUnset: { $0._storage.__Line__ == nil }),
+    .singularInt32({ $0.___ }, fieldNumber: 65, isUnset: { $0._storage.____ == nil }),
+    .singularInt32({ $0.associativity }, fieldNumber: 66, isUnset: { $0._storage._associativity == nil }),
+    .singularInt32({ $0.convenience }, fieldNumber: 67, isUnset: { $0._storage._convenience == nil }),
+    .singularInt32({ $0.dynamic }, fieldNumber: 68, isUnset: { $0._storage._dynamic == nil }),
+    .singularInt32({ $0.didSet }, fieldNumber: 69, isUnset: { $0._storage._didSet == nil }),
+    .singularInt32({ $0.final }, fieldNumber: 70, isUnset: { $0._storage._final == nil }),
+    .singularInt32({ $0.get }, fieldNumber: 71, isUnset: { $0._storage._get == nil }),
+    .singularInt32({ $0.infix }, fieldNumber: 72, isUnset: { $0._storage._infix == nil }),
+    .singularInt32({ $0.indirect }, fieldNumber: 73, isUnset: { $0._storage._indirect == nil }),
+    .singularInt32({ $0.lazy }, fieldNumber: 74, isUnset: { $0._storage._lazy == nil }),
+    .singularInt32({ $0.left }, fieldNumber: 75, isUnset: { $0._storage._left == nil }),
+    .singularInt32({ $0.mutating }, fieldNumber: 76, isUnset: { $0._storage._mutating == nil }),
+    .singularInt32({ $0.none }, fieldNumber: 77, isUnset: { $0._storage._none == nil }),
+    .singularInt32({ $0.nonmutating }, fieldNumber: 78, isUnset: { $0._storage._nonmutating == nil }),
+    .singularInt32({ $0.optional }, fieldNumber: 79, isUnset: { $0._storage._optional == nil }),
+    .singularInt32({ $0.override }, fieldNumber: 80, isUnset: { $0._storage._override == nil }),
+    .singularInt32({ $0.postfix }, fieldNumber: 81, isUnset: { $0._storage._postfix == nil }),
+    .singularInt32({ $0.precedence }, fieldNumber: 82, isUnset: { $0._storage._precedence == nil }),
+    .singularInt32({ $0.prefix }, fieldNumber: 83, isUnset: { $0._storage._prefix == nil }),
+    .singularInt32({ $0.required }, fieldNumber: 85, isUnset: { $0._storage._required == nil }),
+    .singularInt32({ $0.right }, fieldNumber: 86, isUnset: { $0._storage._right == nil }),
+    .singularInt32({ $0.set }, fieldNumber: 87, isUnset: { $0._storage._set == nil }),
+    .singularInt32({ $0.type }, fieldNumber: 88, isUnset: { $0._storage._type == nil }),
+    .singularInt32({ $0.unowned }, fieldNumber: 89, isUnset: { $0._storage._unowned == nil }),
+    .singularInt32({ $0.weak }, fieldNumber: 90, isUnset: { $0._storage._weak == nil }),
+    .singularInt32({ $0.willSet }, fieldNumber: 91, isUnset: { $0._storage._willSet == nil }),
+    .singularInt32({ $0.id }, fieldNumber: 92, isUnset: { $0._storage._id == nil }),
+    .singularInt32({ $0.cmd }, fieldNumber: 93, isUnset: { $0._storage._cmd == nil }),
+    .singularInt32({ $0.out }, fieldNumber: 96, isUnset: { $0._storage._out == nil }),
+    .singularInt32({ $0.bycopy }, fieldNumber: 98, isUnset: { $0._storage._bycopy == nil }),
+    .singularInt32({ $0.byref }, fieldNumber: 99, isUnset: { $0._storage._byref == nil }),
+    .singularInt32({ $0.oneway }, fieldNumber: 100, isUnset: { $0._storage._oneway == nil }),
+    .singularInt32({ $0.and }, fieldNumber: 102, isUnset: { $0._storage._and == nil }),
+    .singularInt32({ $0.andEq }, fieldNumber: 103, isUnset: { $0._storage._andEq == nil }),
+    .singularInt32({ $0.alignas }, fieldNumber: 104, isUnset: { $0._storage._alignas == nil }),
+    .singularInt32({ $0.alignof }, fieldNumber: 105, isUnset: { $0._storage._alignof == nil }),
+    .singularInt32({ $0.asm }, fieldNumber: 106, isUnset: { $0._storage._asm == nil }),
+    .singularInt32({ $0.auto }, fieldNumber: 107, isUnset: { $0._storage._auto == nil }),
+    .singularInt32({ $0.bitand }, fieldNumber: 108, isUnset: { $0._storage._bitand == nil }),
+    .singularInt32({ $0.bitor }, fieldNumber: 109, isUnset: { $0._storage._bitor == nil }),
+    .singularInt32({ $0.bool }, fieldNumber: 110, isUnset: { $0._storage._bool == nil }),
+    .singularInt32({ $0.char }, fieldNumber: 114, isUnset: { $0._storage._char == nil }),
+    .singularInt32({ $0.char16T }, fieldNumber: 115, isUnset: { $0._storage._char16T == nil }),
+    .singularInt32({ $0.char32T }, fieldNumber: 116, isUnset: { $0._storage._char32T == nil }),
+    .singularInt32({ $0.compl }, fieldNumber: 118, isUnset: { $0._storage._compl == nil }),
+    .singularInt32({ $0.const }, fieldNumber: 119, isUnset: { $0._storage._const == nil }),
+    .singularInt32({ $0.constexpr }, fieldNumber: 120, isUnset: { $0._storage._constexpr == nil }),
+    .singularInt32({ $0.constCast }, fieldNumber: 121, isUnset: { $0._storage._constCast == nil }),
+    .singularInt32({ $0.decltype }, fieldNumber: 123, isUnset: { $0._storage._decltype == nil }),
+    .singularInt32({ $0.delete }, fieldNumber: 125, isUnset: { $0._storage._delete == nil }),
+    .singularInt32({ $0.dynamicCast }, fieldNumber: 127, isUnset: { $0._storage._dynamicCast == nil }),
+    .singularInt32({ $0.explicit }, fieldNumber: 130, isUnset: { $0._storage._explicit == nil }),
+    .singularInt32({ $0.export }, fieldNumber: 131, isUnset: { $0._storage._export == nil }),
+    .singularInt32({ $0.extern }, fieldNumber: 132, isUnset: { $0._storage._extern == nil }),
+    .singularInt32({ $0.friend }, fieldNumber: 136, isUnset: { $0._storage._friend == nil }),
+    .singularInt32({ $0.goto }, fieldNumber: 137, isUnset: { $0._storage._goto == nil }),
+    .singularInt32({ $0.inline }, fieldNumber: 139, isUnset: { $0._storage._inline == nil }),
+    .singularInt32({ $0.long }, fieldNumber: 141, isUnset: { $0._storage._long == nil }),
+    .singularInt32({ $0.mutable }, fieldNumber: 142, isUnset: { $0._storage._mutable == nil }),
+    .singularInt32({ $0.namespace }, fieldNumber: 143, isUnset: { $0._storage._namespace == nil }),
+    .singularInt32({ $0.new }, fieldNumber: 144, isUnset: { $0._storage._new == nil }),
+    .singularInt32({ $0.noexcept }, fieldNumber: 145, isUnset: { $0._storage._noexcept == nil }),
+    .singularInt32({ $0.not }, fieldNumber: 146, isUnset: { $0._storage._not == nil }),
+    .singularInt32({ $0.notEq }, fieldNumber: 147, isUnset: { $0._storage._notEq == nil }),
+    .singularInt32({ $0.nullptr }, fieldNumber: 148, isUnset: { $0._storage._nullptr == nil }),
+    .singularInt32({ $0.or }, fieldNumber: 150, isUnset: { $0._storage._or == nil }),
+    .singularInt32({ $0.orEq }, fieldNumber: 151, isUnset: { $0._storage._orEq == nil }),
+    .singularInt32({ $0.protected }, fieldNumber: 153, isUnset: { $0._storage._protected == nil }),
+    .singularInt32({ $0.register }, fieldNumber: 155, isUnset: { $0._storage._register == nil }),
+    .singularInt32({ $0.reinterpretCast }, fieldNumber: 156, isUnset: { $0._storage._reinterpretCast == nil }),
+    .singularInt32({ $0.short }, fieldNumber: 158, isUnset: { $0._storage._short == nil }),
+    .singularInt32({ $0.signed }, fieldNumber: 159, isUnset: { $0._storage._signed == nil }),
+    .singularInt32({ $0.sizeof }, fieldNumber: 160, isUnset: { $0._storage._sizeof == nil }),
+    .singularInt32({ $0.staticAssert }, fieldNumber: 162, isUnset: { $0._storage._staticAssert == nil }),
+    .singularInt32({ $0.staticCast }, fieldNumber: 163, isUnset: { $0._storage._staticCast == nil }),
+    .singularInt32({ $0.template }, fieldNumber: 166, isUnset: { $0._storage._template == nil }),
+    .singularInt32({ $0.this }, fieldNumber: 167, isUnset: { $0._storage._this == nil }),
+    .singularInt32({ $0.threadLocal }, fieldNumber: 168, isUnset: { $0._storage._threadLocal == nil }),
+    .singularInt32({ $0.typedef }, fieldNumber: 172, isUnset: { $0._storage._typedef == nil }),
+    .singularInt32({ $0.typeid }, fieldNumber: 173, isUnset: { $0._storage._typeid == nil }),
+    .singularInt32({ $0.typename }, fieldNumber: 174, isUnset: { $0._storage._typename == nil }),
+    .singularInt32({ $0.union }, fieldNumber: 175, isUnset: { $0._storage._union == nil }),
+    .singularInt32({ $0.unsigned }, fieldNumber: 176, isUnset: { $0._storage._unsigned == nil }),
+    .singularInt32({ $0.using }, fieldNumber: 177, isUnset: { $0._storage._using == nil }),
+    .singularInt32({ $0.virtual }, fieldNumber: 178, isUnset: { $0._storage._virtual == nil }),
+    .singularInt32({ $0.void }, fieldNumber: 179, isUnset: { $0._storage._void == nil }),
+    .singularInt32({ $0.volatile }, fieldNumber: 180, isUnset: { $0._storage._volatile == nil }),
+    .singularInt32({ $0.wcharT }, fieldNumber: 181, isUnset: { $0._storage._wcharT == nil }),
+    .singularInt32({ $0.xor }, fieldNumber: 183, isUnset: { $0._storage._xor == nil }),
+    .singularInt32({ $0.xorEq }, fieldNumber: 184, isUnset: { $0._storage._xorEq == nil }),
+    .singularInt32({ $0.restrict }, fieldNumber: 185, isUnset: { $0._storage._restrict == nil }),
+    .singularInt32({ $0.category }, fieldNumber: 186, isUnset: { $0._storage._category == nil }),
+    .singularInt32({ $0.ivar }, fieldNumber: 187, isUnset: { $0._storage._ivar == nil }),
+    .singularInt32({ $0.method }, fieldNumber: 188, isUnset: { $0._storage._method == nil }),
+    .singularInt32({ $0.finalize }, fieldNumber: 192, isUnset: { $0._storage._finalize == nil }),
+    .singularInt32({ $0.hash }, fieldNumber: 193, isUnset: { $0._storage._hash == nil }),
+    .singularInt32({ $0.dealloc }, fieldNumber: 194, isUnset: { $0._storage._dealloc == nil }),
+    .singularInt32({ $0.superclass }, fieldNumber: 197, isUnset: { $0._storage._superclass == nil }),
+    .singularInt32({ $0.retain }, fieldNumber: 198, isUnset: { $0._storage._retain == nil }),
+    .singularInt32({ $0.release }, fieldNumber: 199, isUnset: { $0._storage._release == nil }),
+    .singularInt32({ $0.autorelease }, fieldNumber: 200, isUnset: { $0._storage._autorelease == nil }),
+    .singularInt32({ $0.retainCount }, fieldNumber: 201, isUnset: { $0._storage._retainCount == nil }),
+    .singularInt32({ $0.zone }, fieldNumber: 202, isUnset: { $0._storage._zone == nil }),
+    .singularInt32({ $0.isProxy }, fieldNumber: 203, isUnset: { $0._storage._isProxy == nil }),
+    .singularInt32({ $0.copy }, fieldNumber: 204, isUnset: { $0._storage._copy == nil }),
+    .singularInt32({ $0.mutableCopy }, fieldNumber: 205, isUnset: { $0._storage._mutableCopy == nil }),
+    .singularInt32({ $0.classForCoder }, fieldNumber: 206, isUnset: { $0._storage._classForCoder == nil }),
+    .singularInt32({ $0.clear }, fieldNumber: 207, isUnset: { $0._storage._clear == nil }),
+    .singularInt32({ $0.data }, fieldNumber: 208, isUnset: { $0._storage._data == nil }),
+    .singularInt32({ $0.delimitedData }, fieldNumber: 209, isUnset: { $0._storage._delimitedData == nil }),
+    .singularInt32({ $0.descriptor }, fieldNumber: 210, isUnset: { $0._storage._descriptor == nil }),
+    .singularInt32({ $0.extensionRegistry }, fieldNumber: 211, isUnset: { $0._storage._extensionRegistry == nil }),
+    .singularInt32({ $0.extensionsCurrentlySet }, fieldNumber: 212, isUnset: { $0._storage._extensionsCurrentlySet == nil }),
+    .singularInt32({ $0.isInitialized_p }, fieldNumber: 213, isUnset: { $0._storage._isInitialized_p == nil }),
+    .singularInt32({ $0.serializedSize }, fieldNumber: 214, isUnset: { $0._storage._serializedSize == nil }),
+    .singularInt32({ $0.sortedExtensionsInUse }, fieldNumber: 215, isUnset: { $0._storage._sortedExtensionsInUse == nil }),
+    .singularInt32({ $0.unknownFields_p }, fieldNumber: 216, isUnset: { $0._storage._unknownFields_p == nil }),
+    .singularInt32({ $0.fixed }, fieldNumber: 217, isUnset: { $0._storage._fixed == nil }),
+    .singularInt32({ $0.fract }, fieldNumber: 218, isUnset: { $0._storage._fract == nil }),
+    .singularInt32({ $0.size }, fieldNumber: 219, isUnset: { $0._storage._size == nil }),
+    .singularInt32({ $0.logicalAddress }, fieldNumber: 220, isUnset: { $0._storage._logicalAddress == nil }),
+    .singularInt32({ $0.physicalAddress }, fieldNumber: 221, isUnset: { $0._storage._physicalAddress == nil }),
+    .singularInt32({ $0.byteCount }, fieldNumber: 222, isUnset: { $0._storage._byteCount == nil }),
+    .singularInt32({ $0.byteOffset }, fieldNumber: 223, isUnset: { $0._storage._byteOffset == nil }),
+    .singularInt32({ $0.duration }, fieldNumber: 224, isUnset: { $0._storage._duration == nil }),
+    .singularInt32({ $0.absoluteTime }, fieldNumber: 225, isUnset: { $0._storage._absoluteTime == nil }),
+    .singularInt32({ $0.optionBits }, fieldNumber: 226, isUnset: { $0._storage._optionBits == nil }),
+    .singularInt32({ $0.itemCount }, fieldNumber: 227, isUnset: { $0._storage._itemCount == nil }),
+    .singularInt32({ $0.pbversion }, fieldNumber: 228, isUnset: { $0._storage._pbversion == nil }),
+    .singularInt32({ $0.scriptCode }, fieldNumber: 229, isUnset: { $0._storage._scriptCode == nil }),
+    .singularInt32({ $0.langCode }, fieldNumber: 230, isUnset: { $0._storage._langCode == nil }),
+    .singularInt32({ $0.regionCode }, fieldNumber: 231, isUnset: { $0._storage._regionCode == nil }),
+    .singularInt32({ $0.ostype }, fieldNumber: 232, isUnset: { $0._storage._ostype == nil }),
+    .singularInt32({ $0.processSerialNumber }, fieldNumber: 233, isUnset: { $0._storage._processSerialNumber == nil }),
+    .singularInt32({ $0.point }, fieldNumber: 234, isUnset: { $0._storage._point == nil }),
+    .singularInt32({ $0.rect }, fieldNumber: 235, isUnset: { $0._storage._rect == nil }),
+    .singularInt32({ $0.fixedPoint }, fieldNumber: 236, isUnset: { $0._storage._fixedPoint == nil }),
+    .singularInt32({ $0.fixedRect }, fieldNumber: 237, isUnset: { $0._storage._fixedRect == nil }),
+    .singularInt32({ $0.style }, fieldNumber: 238, isUnset: { $0._storage._style == nil }),
+    .singularInt32({ $0.styleParameter }, fieldNumber: 239, isUnset: { $0._storage._styleParameter == nil }),
+    .singularInt32({ $0.styleField }, fieldNumber: 240, isUnset: { $0._storage._styleField == nil }),
+    .singularInt32({ $0.timeScale }, fieldNumber: 241, isUnset: { $0._storage._timeScale == nil }),
+    .singularInt32({ $0.timeBase }, fieldNumber: 242, isUnset: { $0._storage._timeBase == nil }),
+    .singularInt32({ $0.timeRecord }, fieldNumber: 243, isUnset: { $0._storage._timeRecord == nil }),
+    .singularInt32({ $0.jsonShouldBeOverridden }, fieldNumber: 244, isUnset: { $0._storage._jsonShouldBeOverridden == nil }),
+    .singularInt32({ $0.any }, fieldNumber: 245, isUnset: { $0._storage._any == nil }),
+    .singularInt32({ $0.int32 }, fieldNumber: 246, isUnset: { $0._storage._int32 == nil }),
+    .singularInt32({ $0.int64 }, fieldNumber: 247, isUnset: { $0._storage._int64 == nil }),
+    .singularInt32({ $0.uint32 }, fieldNumber: 250, isUnset: { $0._storage._uint32 == nil }),
+    .singularInt32({ $0.uint64 }, fieldNumber: 251, isUnset: { $0._storage._uint64 == nil }),
+    .singularInt32({ $0.`associatedtype` }, fieldNumber: 252, isUnset: { $0._storage._associatedtype == nil }),
+    .singularInt32({ $0.`fileprivate` }, fieldNumber: 253, isUnset: { $0._storage._fileprivate == nil }),
+    .singularInt32({ $0.`open` }, fieldNumber: 254, isUnset: { $0._storage._open == nil }),
+    .singularInt32({ $0.serializedData }, fieldNumber: 255, isUnset: { $0._storage._serializedData == nil }),
+    .singularInt32({ $0.hasSerializedData_p }, fieldNumber: 256, isUnset: { $0._storage._hasSerializedData_p == nil }),
+    .singularInt32({ $0.clearSerializedData_p }, fieldNumber: 257, isUnset: { $0._storage._clearSerializedData_p == nil }),
+    .singularInt32({ $0.jsonUtf8Data }, fieldNumber: 258, isUnset: { $0._storage._jsonUtf8Data == nil }),
+    .singularInt32({ $0.jsonString }, fieldNumber: 259, isUnset: { $0._storage._jsonString == nil }),
+    .singularInt32({ $0.`extension` }, fieldNumber: 260, isUnset: { $0._storage._extension == nil }),
+    .singularInt32({ $0.extensions }, fieldNumber: 261, isUnset: { $0._storage._extensions == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_FieldNames, rhs: SwiftProtoTesting_Names_FieldNames) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -17240,9 +16790,9 @@ extension SwiftProtoTesting_Names_MessageNames: SwiftProtobuf.Message, SwiftProt
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames, rhs: SwiftProtoTesting_Names_MessageNames) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -17268,16 +16818,10 @@ extension SwiftProtoTesting_Names_MessageNames.StringMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._string {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.string }, fieldNumber: 1, isUnset: { $0._string == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.StringMessage, rhs: SwiftProtoTesting_Names_MessageNames.StringMessage) -> Bool {
     if lhs._string != rhs._string {return false}
@@ -17304,16 +16848,10 @@ extension SwiftProtoTesting_Names_MessageNames.ProtocolMessage: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._protocol {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`protocol` }, fieldNumber: 1, isUnset: { $0._protocol == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ProtocolMessage, rhs: SwiftProtoTesting_Names_MessageNames.ProtocolMessage) -> Bool {
     if lhs._protocol != rhs._protocol {return false}
@@ -17340,16 +16878,10 @@ extension SwiftProtoTesting_Names_MessageNames.IntMessage: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._int {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.int }, fieldNumber: 1, isUnset: { $0._int == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.IntMessage, rhs: SwiftProtoTesting_Names_MessageNames.IntMessage) -> Bool {
     if lhs._int != rhs._int {return false}
@@ -17376,16 +16908,10 @@ extension SwiftProtoTesting_Names_MessageNames.DoubleMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._double {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.double }, fieldNumber: 1, isUnset: { $0._double == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.DoubleMessage, rhs: SwiftProtoTesting_Names_MessageNames.DoubleMessage) -> Bool {
     if lhs._double != rhs._double {return false}
@@ -17412,16 +16938,10 @@ extension SwiftProtoTesting_Names_MessageNames.FloatMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._float {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.float }, fieldNumber: 1, isUnset: { $0._float == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.FloatMessage, rhs: SwiftProtoTesting_Names_MessageNames.FloatMessage) -> Bool {
     if lhs._float != rhs._float {return false}
@@ -17448,16 +16968,10 @@ extension SwiftProtoTesting_Names_MessageNames.UIntMessage: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._uint {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.uint }, fieldNumber: 1, isUnset: { $0._uint == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.UIntMessage, rhs: SwiftProtoTesting_Names_MessageNames.UIntMessage) -> Bool {
     if lhs._uint != rhs._uint {return false}
@@ -17484,16 +16998,10 @@ extension SwiftProtoTesting_Names_MessageNames.hashValueMessage: SwiftProtobuf.M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._hashValue_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hashValue_p }, fieldNumber: 1, isUnset: { $0._hashValue_p == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.hashValueMessage, rhs: SwiftProtoTesting_Names_MessageNames.hashValueMessage) -> Bool {
     if lhs._hashValue_p != rhs._hashValue_p {return false}
@@ -17520,16 +17028,10 @@ extension SwiftProtoTesting_Names_MessageNames.descriptionMessage: SwiftProtobuf
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._description_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.description_p }, fieldNumber: 1, isUnset: { $0._description_p == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.descriptionMessage, rhs: SwiftProtoTesting_Names_MessageNames.descriptionMessage) -> Bool {
     if lhs._description_p != rhs._description_p {return false}
@@ -17556,16 +17058,10 @@ extension SwiftProtoTesting_Names_MessageNames.debugDescriptionMessage: SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._debugDescription_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.debugDescription_p }, fieldNumber: 1, isUnset: { $0._debugDescription_p == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.debugDescriptionMessage, rhs: SwiftProtoTesting_Names_MessageNames.debugDescriptionMessage) -> Bool {
     if lhs._debugDescription_p != rhs._debugDescription_p {return false}
@@ -17592,16 +17088,10 @@ extension SwiftProtoTesting_Names_MessageNames.SwiftMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._swift {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.swift }, fieldNumber: 1, isUnset: { $0._swift == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.SwiftMessage, rhs: SwiftProtoTesting_Names_MessageNames.SwiftMessage) -> Bool {
     if lhs._swift != rhs._swift {return false}
@@ -17628,16 +17118,10 @@ extension SwiftProtoTesting_Names_MessageNames.UNRECOGNIZED: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._unrecognized {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unrecognized }, fieldNumber: 1, isUnset: { $0._unrecognized == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.UNRECOGNIZED, rhs: SwiftProtoTesting_Names_MessageNames.UNRECOGNIZED) -> Bool {
     if lhs._unrecognized != rhs._unrecognized {return false}
@@ -17664,16 +17148,10 @@ extension SwiftProtoTesting_Names_MessageNames.classMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._class {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`class` }, fieldNumber: 1, isUnset: { $0._class == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.classMessage, rhs: SwiftProtoTesting_Names_MessageNames.classMessage) -> Bool {
     if lhs._class != rhs._class {return false}
@@ -17700,16 +17178,10 @@ extension SwiftProtoTesting_Names_MessageNames.deinitMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._deinit {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`deinit` }, fieldNumber: 1, isUnset: { $0._deinit == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.deinitMessage, rhs: SwiftProtoTesting_Names_MessageNames.deinitMessage) -> Bool {
     if lhs._deinit != rhs._deinit {return false}
@@ -17736,16 +17208,10 @@ extension SwiftProtoTesting_Names_MessageNames.enumMessage: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._enum {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`enum` }, fieldNumber: 1, isUnset: { $0._enum == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.enumMessage, rhs: SwiftProtoTesting_Names_MessageNames.enumMessage) -> Bool {
     if lhs._enum != rhs._enum {return false}
@@ -17772,16 +17238,10 @@ extension SwiftProtoTesting_Names_MessageNames.extensionMessage: SwiftProtobuf.M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._extension {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`extension` }, fieldNumber: 1, isUnset: { $0._extension == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extensionMessage, rhs: SwiftProtoTesting_Names_MessageNames.extensionMessage) -> Bool {
     if lhs._extension != rhs._extension {return false}
@@ -17808,16 +17268,10 @@ extension SwiftProtoTesting_Names_MessageNames.funcMessage: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._func {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`func` }, fieldNumber: 1, isUnset: { $0._func == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.funcMessage, rhs: SwiftProtoTesting_Names_MessageNames.funcMessage) -> Bool {
     if lhs._func != rhs._func {return false}
@@ -17844,16 +17298,10 @@ extension SwiftProtoTesting_Names_MessageNames.importMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._import {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`import` }, fieldNumber: 1, isUnset: { $0._import == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.importMessage, rhs: SwiftProtoTesting_Names_MessageNames.importMessage) -> Bool {
     if lhs._import != rhs._import {return false}
@@ -17880,16 +17328,10 @@ extension SwiftProtoTesting_Names_MessageNames.initMessage: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._init_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.init_p }, fieldNumber: 1, isUnset: { $0._init_p == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.initMessage, rhs: SwiftProtoTesting_Names_MessageNames.initMessage) -> Bool {
     if lhs._init_p != rhs._init_p {return false}
@@ -17916,16 +17358,10 @@ extension SwiftProtoTesting_Names_MessageNames.inoutMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._inout {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`inout` }, fieldNumber: 1, isUnset: { $0._inout == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.inoutMessage, rhs: SwiftProtoTesting_Names_MessageNames.inoutMessage) -> Bool {
     if lhs._inout != rhs._inout {return false}
@@ -17952,16 +17388,10 @@ extension SwiftProtoTesting_Names_MessageNames.internalMessage: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._internal {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`internal` }, fieldNumber: 1, isUnset: { $0._internal == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.internalMessage, rhs: SwiftProtoTesting_Names_MessageNames.internalMessage) -> Bool {
     if lhs._internal != rhs._internal {return false}
@@ -17988,16 +17418,10 @@ extension SwiftProtoTesting_Names_MessageNames.letMessage: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._let {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`let` }, fieldNumber: 1, isUnset: { $0._let == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.letMessage, rhs: SwiftProtoTesting_Names_MessageNames.letMessage) -> Bool {
     if lhs._let != rhs._let {return false}
@@ -18024,16 +17448,10 @@ extension SwiftProtoTesting_Names_MessageNames.operatorMessage: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._operator {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`operator` }, fieldNumber: 1, isUnset: { $0._operator == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.operatorMessage, rhs: SwiftProtoTesting_Names_MessageNames.operatorMessage) -> Bool {
     if lhs._operator != rhs._operator {return false}
@@ -18060,16 +17478,10 @@ extension SwiftProtoTesting_Names_MessageNames.privateMessage: SwiftProtobuf.Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._private {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`private` }, fieldNumber: 1, isUnset: { $0._private == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.privateMessage, rhs: SwiftProtoTesting_Names_MessageNames.privateMessage) -> Bool {
     if lhs._private != rhs._private {return false}
@@ -18096,16 +17508,10 @@ extension SwiftProtoTesting_Names_MessageNames.protocolMessage: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._protocol {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`protocol` }, fieldNumber: 1, isUnset: { $0._protocol == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.protocolMessage, rhs: SwiftProtoTesting_Names_MessageNames.protocolMessage) -> Bool {
     if lhs._protocol != rhs._protocol {return false}
@@ -18132,16 +17538,10 @@ extension SwiftProtoTesting_Names_MessageNames.publicMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._public {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`public` }, fieldNumber: 1, isUnset: { $0._public == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.publicMessage, rhs: SwiftProtoTesting_Names_MessageNames.publicMessage) -> Bool {
     if lhs._public != rhs._public {return false}
@@ -18168,16 +17568,10 @@ extension SwiftProtoTesting_Names_MessageNames.staticMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._static {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`static` }, fieldNumber: 1, isUnset: { $0._static == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.staticMessage, rhs: SwiftProtoTesting_Names_MessageNames.staticMessage) -> Bool {
     if lhs._static != rhs._static {return false}
@@ -18204,16 +17598,10 @@ extension SwiftProtoTesting_Names_MessageNames.structMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._struct {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`struct` }, fieldNumber: 1, isUnset: { $0._struct == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.structMessage, rhs: SwiftProtoTesting_Names_MessageNames.structMessage) -> Bool {
     if lhs._struct != rhs._struct {return false}
@@ -18240,16 +17628,10 @@ extension SwiftProtoTesting_Names_MessageNames.subscriptMessage: SwiftProtobuf.M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._subscript {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`subscript` }, fieldNumber: 1, isUnset: { $0._subscript == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.subscriptMessage, rhs: SwiftProtoTesting_Names_MessageNames.subscriptMessage) -> Bool {
     if lhs._subscript != rhs._subscript {return false}
@@ -18276,16 +17658,10 @@ extension SwiftProtoTesting_Names_MessageNames.typealiasMessage: SwiftProtobuf.M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._typealias {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`typealias` }, fieldNumber: 1, isUnset: { $0._typealias == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typealiasMessage, rhs: SwiftProtoTesting_Names_MessageNames.typealiasMessage) -> Bool {
     if lhs._typealias != rhs._typealias {return false}
@@ -18312,16 +17688,10 @@ extension SwiftProtoTesting_Names_MessageNames.varMessage: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._var {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`var` }, fieldNumber: 1, isUnset: { $0._var == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.varMessage, rhs: SwiftProtoTesting_Names_MessageNames.varMessage) -> Bool {
     if lhs._var != rhs._var {return false}
@@ -18348,16 +17718,10 @@ extension SwiftProtoTesting_Names_MessageNames.breakMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._break {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`break` }, fieldNumber: 1, isUnset: { $0._break == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.breakMessage, rhs: SwiftProtoTesting_Names_MessageNames.breakMessage) -> Bool {
     if lhs._break != rhs._break {return false}
@@ -18384,16 +17748,10 @@ extension SwiftProtoTesting_Names_MessageNames.caseMessage: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._case {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`case` }, fieldNumber: 1, isUnset: { $0._case == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.caseMessage, rhs: SwiftProtoTesting_Names_MessageNames.caseMessage) -> Bool {
     if lhs._case != rhs._case {return false}
@@ -18420,16 +17778,10 @@ extension SwiftProtoTesting_Names_MessageNames.continueMessage: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._continue {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`continue` }, fieldNumber: 1, isUnset: { $0._continue == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.continueMessage, rhs: SwiftProtoTesting_Names_MessageNames.continueMessage) -> Bool {
     if lhs._continue != rhs._continue {return false}
@@ -18456,16 +17808,10 @@ extension SwiftProtoTesting_Names_MessageNames.defaultMessage: SwiftProtobuf.Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._default {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`default` }, fieldNumber: 1, isUnset: { $0._default == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.defaultMessage, rhs: SwiftProtoTesting_Names_MessageNames.defaultMessage) -> Bool {
     if lhs._default != rhs._default {return false}
@@ -18492,16 +17838,10 @@ extension SwiftProtoTesting_Names_MessageNames.deferMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._defer {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`defer` }, fieldNumber: 1, isUnset: { $0._defer == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.deferMessage, rhs: SwiftProtoTesting_Names_MessageNames.deferMessage) -> Bool {
     if lhs._defer != rhs._defer {return false}
@@ -18528,16 +17868,10 @@ extension SwiftProtoTesting_Names_MessageNames.doMessage: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._do {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`do` }, fieldNumber: 1, isUnset: { $0._do == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.doMessage, rhs: SwiftProtoTesting_Names_MessageNames.doMessage) -> Bool {
     if lhs._do != rhs._do {return false}
@@ -18564,16 +17898,10 @@ extension SwiftProtoTesting_Names_MessageNames.elseMessage: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._else {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`else` }, fieldNumber: 1, isUnset: { $0._else == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.elseMessage, rhs: SwiftProtoTesting_Names_MessageNames.elseMessage) -> Bool {
     if lhs._else != rhs._else {return false}
@@ -18600,16 +17928,10 @@ extension SwiftProtoTesting_Names_MessageNames.fallthroughMessage: SwiftProtobuf
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._fallthrough {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`fallthrough` }, fieldNumber: 1, isUnset: { $0._fallthrough == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.fallthroughMessage, rhs: SwiftProtoTesting_Names_MessageNames.fallthroughMessage) -> Bool {
     if lhs._fallthrough != rhs._fallthrough {return false}
@@ -18636,16 +17958,10 @@ extension SwiftProtoTesting_Names_MessageNames.forMessage: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._for {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`for` }, fieldNumber: 1, isUnset: { $0._for == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.forMessage, rhs: SwiftProtoTesting_Names_MessageNames.forMessage) -> Bool {
     if lhs._for != rhs._for {return false}
@@ -18672,16 +17988,10 @@ extension SwiftProtoTesting_Names_MessageNames.guardMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._guard {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`guard` }, fieldNumber: 1, isUnset: { $0._guard == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.guardMessage, rhs: SwiftProtoTesting_Names_MessageNames.guardMessage) -> Bool {
     if lhs._guard != rhs._guard {return false}
@@ -18708,16 +18018,10 @@ extension SwiftProtoTesting_Names_MessageNames.ifMessage: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._if {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`if` }, fieldNumber: 1, isUnset: { $0._if == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ifMessage, rhs: SwiftProtoTesting_Names_MessageNames.ifMessage) -> Bool {
     if lhs._if != rhs._if {return false}
@@ -18744,16 +18048,10 @@ extension SwiftProtoTesting_Names_MessageNames.inMessage: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._in {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`in` }, fieldNumber: 1, isUnset: { $0._in == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.inMessage, rhs: SwiftProtoTesting_Names_MessageNames.inMessage) -> Bool {
     if lhs._in != rhs._in {return false}
@@ -18780,16 +18078,10 @@ extension SwiftProtoTesting_Names_MessageNames.repeatMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._repeat {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`repeat` }, fieldNumber: 1, isUnset: { $0._repeat == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.repeatMessage, rhs: SwiftProtoTesting_Names_MessageNames.repeatMessage) -> Bool {
     if lhs._repeat != rhs._repeat {return false}
@@ -18816,16 +18108,10 @@ extension SwiftProtoTesting_Names_MessageNames.returnMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._return {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`return` }, fieldNumber: 1, isUnset: { $0._return == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.returnMessage, rhs: SwiftProtoTesting_Names_MessageNames.returnMessage) -> Bool {
     if lhs._return != rhs._return {return false}
@@ -18852,16 +18138,10 @@ extension SwiftProtoTesting_Names_MessageNames.switchMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._switch {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`switch` }, fieldNumber: 1, isUnset: { $0._switch == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.switchMessage, rhs: SwiftProtoTesting_Names_MessageNames.switchMessage) -> Bool {
     if lhs._switch != rhs._switch {return false}
@@ -18888,16 +18168,10 @@ extension SwiftProtoTesting_Names_MessageNames.whereMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._where {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`where` }, fieldNumber: 1, isUnset: { $0._where == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.whereMessage, rhs: SwiftProtoTesting_Names_MessageNames.whereMessage) -> Bool {
     if lhs._where != rhs._where {return false}
@@ -18924,16 +18198,10 @@ extension SwiftProtoTesting_Names_MessageNames.whileMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._while {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`while` }, fieldNumber: 1, isUnset: { $0._while == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.whileMessage, rhs: SwiftProtoTesting_Names_MessageNames.whileMessage) -> Bool {
     if lhs._while != rhs._while {return false}
@@ -18960,16 +18228,10 @@ extension SwiftProtoTesting_Names_MessageNames.asMessage: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._as {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`as` }, fieldNumber: 1, isUnset: { $0._as == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.asMessage, rhs: SwiftProtoTesting_Names_MessageNames.asMessage) -> Bool {
     if lhs._as != rhs._as {return false}
@@ -18996,16 +18258,10 @@ extension SwiftProtoTesting_Names_MessageNames.catchMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._catch {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`catch` }, fieldNumber: 1, isUnset: { $0._catch == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.catchMessage, rhs: SwiftProtoTesting_Names_MessageNames.catchMessage) -> Bool {
     if lhs._catch != rhs._catch {return false}
@@ -19032,16 +18288,10 @@ extension SwiftProtoTesting_Names_MessageNames.dynamicTypeMessage: SwiftProtobuf
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._dynamicType_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.dynamicType_p }, fieldNumber: 1, isUnset: { $0._dynamicType_p == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dynamicTypeMessage, rhs: SwiftProtoTesting_Names_MessageNames.dynamicTypeMessage) -> Bool {
     if lhs._dynamicType_p != rhs._dynamicType_p {return false}
@@ -19068,16 +18318,10 @@ extension SwiftProtoTesting_Names_MessageNames.falseMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._false {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`false` }, fieldNumber: 1, isUnset: { $0._false == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.falseMessage, rhs: SwiftProtoTesting_Names_MessageNames.falseMessage) -> Bool {
     if lhs._false != rhs._false {return false}
@@ -19104,16 +18348,10 @@ extension SwiftProtoTesting_Names_MessageNames.isMessage: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._is {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`is` }, fieldNumber: 1, isUnset: { $0._is == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.isMessage, rhs: SwiftProtoTesting_Names_MessageNames.isMessage) -> Bool {
     if lhs._is != rhs._is {return false}
@@ -19140,16 +18378,10 @@ extension SwiftProtoTesting_Names_MessageNames.nilMessage: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._nil {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`nil` }, fieldNumber: 1, isUnset: { $0._nil == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.nilMessage, rhs: SwiftProtoTesting_Names_MessageNames.nilMessage) -> Bool {
     if lhs._nil != rhs._nil {return false}
@@ -19176,16 +18408,10 @@ extension SwiftProtoTesting_Names_MessageNames.rethrowsMessage: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._rethrows {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`rethrows` }, fieldNumber: 1, isUnset: { $0._rethrows == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.rethrowsMessage, rhs: SwiftProtoTesting_Names_MessageNames.rethrowsMessage) -> Bool {
     if lhs._rethrows != rhs._rethrows {return false}
@@ -19212,16 +18438,10 @@ extension SwiftProtoTesting_Names_MessageNames.superMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._super {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`super` }, fieldNumber: 1, isUnset: { $0._super == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.superMessage, rhs: SwiftProtoTesting_Names_MessageNames.superMessage) -> Bool {
     if lhs._super != rhs._super {return false}
@@ -19248,16 +18468,10 @@ extension SwiftProtoTesting_Names_MessageNames.selfMessage: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._self_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.self_p }, fieldNumber: 1, isUnset: { $0._self_p == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.selfMessage, rhs: SwiftProtoTesting_Names_MessageNames.selfMessage) -> Bool {
     if lhs._self_p != rhs._self_p {return false}
@@ -19284,16 +18498,10 @@ extension SwiftProtoTesting_Names_MessageNames.throwMessage: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._throw {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`throw` }, fieldNumber: 1, isUnset: { $0._throw == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.throwMessage, rhs: SwiftProtoTesting_Names_MessageNames.throwMessage) -> Bool {
     if lhs._throw != rhs._throw {return false}
@@ -19320,16 +18528,10 @@ extension SwiftProtoTesting_Names_MessageNames.throwsMessage: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._throws {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`throws` }, fieldNumber: 1, isUnset: { $0._throws == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.throwsMessage, rhs: SwiftProtoTesting_Names_MessageNames.throwsMessage) -> Bool {
     if lhs._throws != rhs._throws {return false}
@@ -19356,16 +18558,10 @@ extension SwiftProtoTesting_Names_MessageNames.trueMessage: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._true {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`true` }, fieldNumber: 1, isUnset: { $0._true == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.trueMessage, rhs: SwiftProtoTesting_Names_MessageNames.trueMessage) -> Bool {
     if lhs._true != rhs._true {return false}
@@ -19392,16 +18588,10 @@ extension SwiftProtoTesting_Names_MessageNames.tryMessage: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._try {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`try` }, fieldNumber: 1, isUnset: { $0._try == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.tryMessage, rhs: SwiftProtoTesting_Names_MessageNames.tryMessage) -> Bool {
     if lhs._try != rhs._try {return false}
@@ -19428,16 +18618,10 @@ extension SwiftProtoTesting_Names_MessageNames.__COLUMN__Message: SwiftProtobuf.
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self.__Column__ {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0._Column__ }, fieldNumber: 1, isUnset: { $0.__Column__ == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__COLUMN__Message, rhs: SwiftProtoTesting_Names_MessageNames.__COLUMN__Message) -> Bool {
     if lhs.__Column__ != rhs.__Column__ {return false}
@@ -19464,16 +18648,10 @@ extension SwiftProtoTesting_Names_MessageNames.__FILE__Message: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self.__File__ {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0._File__ }, fieldNumber: 1, isUnset: { $0.__File__ == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__FILE__Message, rhs: SwiftProtoTesting_Names_MessageNames.__FILE__Message) -> Bool {
     if lhs.__File__ != rhs.__File__ {return false}
@@ -19500,16 +18678,10 @@ extension SwiftProtoTesting_Names_MessageNames.__FUNCTION__Message: SwiftProtobu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self.__Function__ {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0._Function__ }, fieldNumber: 1, isUnset: { $0.__Function__ == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__FUNCTION__Message, rhs: SwiftProtoTesting_Names_MessageNames.__FUNCTION__Message) -> Bool {
     if lhs.__Function__ != rhs.__Function__ {return false}
@@ -19536,16 +18708,10 @@ extension SwiftProtoTesting_Names_MessageNames.__LINE__Message: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self.__Line__ {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0._Line__ }, fieldNumber: 1, isUnset: { $0.__Line__ == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__LINE__Message, rhs: SwiftProtoTesting_Names_MessageNames.__LINE__Message) -> Bool {
     if lhs.__Line__ != rhs.__Line__ {return false}
@@ -19572,16 +18738,10 @@ extension SwiftProtoTesting_Names_MessageNames._Message: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self.____ {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.___ }, fieldNumber: 1, isUnset: { $0.____ == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames._Message, rhs: SwiftProtoTesting_Names_MessageNames._Message) -> Bool {
     if lhs.____ != rhs.____ {return false}
@@ -19608,16 +18768,10 @@ extension SwiftProtoTesting_Names_MessageNames.__Message: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._____ {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.____ }, fieldNumber: 1, isUnset: { $0._____ == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__Message, rhs: SwiftProtoTesting_Names_MessageNames.__Message) -> Bool {
     if lhs._____ != rhs._____ {return false}
@@ -19644,16 +18798,10 @@ extension SwiftProtoTesting_Names_MessageNames.associativity: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._associativity {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.associativity }, fieldNumber: 1, isUnset: { $0._associativity == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.associativity, rhs: SwiftProtoTesting_Names_MessageNames.associativity) -> Bool {
     if lhs._associativity != rhs._associativity {return false}
@@ -19680,16 +18828,10 @@ extension SwiftProtoTesting_Names_MessageNames.convenience: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._convenience {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.convenience }, fieldNumber: 1, isUnset: { $0._convenience == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.convenience, rhs: SwiftProtoTesting_Names_MessageNames.convenience) -> Bool {
     if lhs._convenience != rhs._convenience {return false}
@@ -19716,16 +18858,10 @@ extension SwiftProtoTesting_Names_MessageNames.dynamic: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._dynamic {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.dynamic }, fieldNumber: 1, isUnset: { $0._dynamic == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dynamic, rhs: SwiftProtoTesting_Names_MessageNames.dynamic) -> Bool {
     if lhs._dynamic != rhs._dynamic {return false}
@@ -19752,16 +18888,10 @@ extension SwiftProtoTesting_Names_MessageNames.didSet: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._didSet {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.didSet }, fieldNumber: 1, isUnset: { $0._didSet == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.didSet, rhs: SwiftProtoTesting_Names_MessageNames.didSet) -> Bool {
     if lhs._didSet != rhs._didSet {return false}
@@ -19788,16 +18918,10 @@ extension SwiftProtoTesting_Names_MessageNames.final: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._final {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.final }, fieldNumber: 1, isUnset: { $0._final == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.final, rhs: SwiftProtoTesting_Names_MessageNames.final) -> Bool {
     if lhs._final != rhs._final {return false}
@@ -19824,16 +18948,10 @@ extension SwiftProtoTesting_Names_MessageNames.get: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._get {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.get }, fieldNumber: 1, isUnset: { $0._get == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.get, rhs: SwiftProtoTesting_Names_MessageNames.get) -> Bool {
     if lhs._get != rhs._get {return false}
@@ -19860,16 +18978,10 @@ extension SwiftProtoTesting_Names_MessageNames.infix: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._infix {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.infix }, fieldNumber: 1, isUnset: { $0._infix == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.infix, rhs: SwiftProtoTesting_Names_MessageNames.infix) -> Bool {
     if lhs._infix != rhs._infix {return false}
@@ -19896,16 +19008,10 @@ extension SwiftProtoTesting_Names_MessageNames.indirect: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._indirect {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.indirect }, fieldNumber: 1, isUnset: { $0._indirect == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.indirect, rhs: SwiftProtoTesting_Names_MessageNames.indirect) -> Bool {
     if lhs._indirect != rhs._indirect {return false}
@@ -19932,16 +19038,10 @@ extension SwiftProtoTesting_Names_MessageNames.lazy: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._lazy {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.lazy }, fieldNumber: 1, isUnset: { $0._lazy == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.lazy, rhs: SwiftProtoTesting_Names_MessageNames.lazy) -> Bool {
     if lhs._lazy != rhs._lazy {return false}
@@ -19968,16 +19068,10 @@ extension SwiftProtoTesting_Names_MessageNames.left: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._left {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.left }, fieldNumber: 1, isUnset: { $0._left == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.left, rhs: SwiftProtoTesting_Names_MessageNames.left) -> Bool {
     if lhs._left != rhs._left {return false}
@@ -20004,16 +19098,10 @@ extension SwiftProtoTesting_Names_MessageNames.mutating: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._mutating {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mutating }, fieldNumber: 1, isUnset: { $0._mutating == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.mutating, rhs: SwiftProtoTesting_Names_MessageNames.mutating) -> Bool {
     if lhs._mutating != rhs._mutating {return false}
@@ -20040,16 +19128,10 @@ extension SwiftProtoTesting_Names_MessageNames.none: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._none {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.none }, fieldNumber: 1, isUnset: { $0._none == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.none, rhs: SwiftProtoTesting_Names_MessageNames.none) -> Bool {
     if lhs._none != rhs._none {return false}
@@ -20076,16 +19158,10 @@ extension SwiftProtoTesting_Names_MessageNames.nonmutating: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._nonmutating {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nonmutating }, fieldNumber: 1, isUnset: { $0._nonmutating == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.nonmutating, rhs: SwiftProtoTesting_Names_MessageNames.nonmutating) -> Bool {
     if lhs._nonmutating != rhs._nonmutating {return false}
@@ -20112,16 +19188,10 @@ extension SwiftProtoTesting_Names_MessageNames.optional: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._optional {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optional }, fieldNumber: 1, isUnset: { $0._optional == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.optional, rhs: SwiftProtoTesting_Names_MessageNames.optional) -> Bool {
     if lhs._optional != rhs._optional {return false}
@@ -20148,16 +19218,10 @@ extension SwiftProtoTesting_Names_MessageNames.override: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._override {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.override }, fieldNumber: 1, isUnset: { $0._override == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.override, rhs: SwiftProtoTesting_Names_MessageNames.override) -> Bool {
     if lhs._override != rhs._override {return false}
@@ -20184,16 +19248,10 @@ extension SwiftProtoTesting_Names_MessageNames.postfix: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._postfix {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.postfix }, fieldNumber: 1, isUnset: { $0._postfix == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.postfix, rhs: SwiftProtoTesting_Names_MessageNames.postfix) -> Bool {
     if lhs._postfix != rhs._postfix {return false}
@@ -20220,16 +19278,10 @@ extension SwiftProtoTesting_Names_MessageNames.precedence: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._precedence {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.precedence }, fieldNumber: 1, isUnset: { $0._precedence == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.precedence, rhs: SwiftProtoTesting_Names_MessageNames.precedence) -> Bool {
     if lhs._precedence != rhs._precedence {return false}
@@ -20256,16 +19308,10 @@ extension SwiftProtoTesting_Names_MessageNames.prefix: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._prefix {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.prefix }, fieldNumber: 1, isUnset: { $0._prefix == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.prefix, rhs: SwiftProtoTesting_Names_MessageNames.prefix) -> Bool {
     if lhs._prefix != rhs._prefix {return false}
@@ -20292,16 +19338,10 @@ extension SwiftProtoTesting_Names_MessageNames.required: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._required {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.required }, fieldNumber: 1, isUnset: { $0._required == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.required, rhs: SwiftProtoTesting_Names_MessageNames.required) -> Bool {
     if lhs._required != rhs._required {return false}
@@ -20328,16 +19368,10 @@ extension SwiftProtoTesting_Names_MessageNames.right: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._right {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.right }, fieldNumber: 1, isUnset: { $0._right == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.right, rhs: SwiftProtoTesting_Names_MessageNames.right) -> Bool {
     if lhs._right != rhs._right {return false}
@@ -20364,16 +19398,10 @@ extension SwiftProtoTesting_Names_MessageNames.set: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._set {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.set }, fieldNumber: 1, isUnset: { $0._set == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.set, rhs: SwiftProtoTesting_Names_MessageNames.set) -> Bool {
     if lhs._set != rhs._set {return false}
@@ -20400,16 +19428,10 @@ extension SwiftProtoTesting_Names_MessageNames.TypeMessage: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._type {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.type }, fieldNumber: 1, isUnset: { $0._type == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TypeMessage, rhs: SwiftProtoTesting_Names_MessageNames.TypeMessage) -> Bool {
     if lhs._type != rhs._type {return false}
@@ -20436,16 +19458,10 @@ extension SwiftProtoTesting_Names_MessageNames.unowned: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._unowned {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unowned }, fieldNumber: 1, isUnset: { $0._unowned == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.unowned, rhs: SwiftProtoTesting_Names_MessageNames.unowned) -> Bool {
     if lhs._unowned != rhs._unowned {return false}
@@ -20472,16 +19488,10 @@ extension SwiftProtoTesting_Names_MessageNames.weak: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._weak {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.weak }, fieldNumber: 1, isUnset: { $0._weak == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.weak, rhs: SwiftProtoTesting_Names_MessageNames.weak) -> Bool {
     if lhs._weak != rhs._weak {return false}
@@ -20508,16 +19518,10 @@ extension SwiftProtoTesting_Names_MessageNames.willSet: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._willSet {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.willSet }, fieldNumber: 1, isUnset: { $0._willSet == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.willSet, rhs: SwiftProtoTesting_Names_MessageNames.willSet) -> Bool {
     if lhs._willSet != rhs._willSet {return false}
@@ -20544,16 +19548,10 @@ extension SwiftProtoTesting_Names_MessageNames.id: SwiftProtobuf.Message, SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._id {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.id }, fieldNumber: 1, isUnset: { $0._id == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.id, rhs: SwiftProtoTesting_Names_MessageNames.id) -> Bool {
     if lhs._id != rhs._id {return false}
@@ -20580,16 +19578,10 @@ extension SwiftProtoTesting_Names_MessageNames._cmd: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._cmd {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.cmd }, fieldNumber: 1, isUnset: { $0._cmd == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames._cmd, rhs: SwiftProtoTesting_Names_MessageNames._cmd) -> Bool {
     if lhs._cmd != rhs._cmd {return false}
@@ -20616,16 +19608,10 @@ extension SwiftProtoTesting_Names_MessageNames.out: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._out {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.out }, fieldNumber: 1, isUnset: { $0._out == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.out, rhs: SwiftProtoTesting_Names_MessageNames.out) -> Bool {
     if lhs._out != rhs._out {return false}
@@ -20652,16 +19638,10 @@ extension SwiftProtoTesting_Names_MessageNames.bycopy: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._bycopy {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bycopy }, fieldNumber: 1, isUnset: { $0._bycopy == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bycopy, rhs: SwiftProtoTesting_Names_MessageNames.bycopy) -> Bool {
     if lhs._bycopy != rhs._bycopy {return false}
@@ -20688,16 +19668,10 @@ extension SwiftProtoTesting_Names_MessageNames.byref: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._byref {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.byref }, fieldNumber: 1, isUnset: { $0._byref == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.byref, rhs: SwiftProtoTesting_Names_MessageNames.byref) -> Bool {
     if lhs._byref != rhs._byref {return false}
@@ -20724,16 +19698,10 @@ extension SwiftProtoTesting_Names_MessageNames.oneway: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._oneway {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.oneway }, fieldNumber: 1, isUnset: { $0._oneway == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.oneway, rhs: SwiftProtoTesting_Names_MessageNames.oneway) -> Bool {
     if lhs._oneway != rhs._oneway {return false}
@@ -20760,16 +19728,10 @@ extension SwiftProtoTesting_Names_MessageNames.and: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._and {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.and }, fieldNumber: 1, isUnset: { $0._and == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.and, rhs: SwiftProtoTesting_Names_MessageNames.and) -> Bool {
     if lhs._and != rhs._and {return false}
@@ -20796,16 +19758,10 @@ extension SwiftProtoTesting_Names_MessageNames.and_eq: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._andEq {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.andEq }, fieldNumber: 1, isUnset: { $0._andEq == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.and_eq, rhs: SwiftProtoTesting_Names_MessageNames.and_eq) -> Bool {
     if lhs._andEq != rhs._andEq {return false}
@@ -20832,16 +19788,10 @@ extension SwiftProtoTesting_Names_MessageNames.alignas: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._alignas {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.alignas }, fieldNumber: 1, isUnset: { $0._alignas == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.alignas, rhs: SwiftProtoTesting_Names_MessageNames.alignas) -> Bool {
     if lhs._alignas != rhs._alignas {return false}
@@ -20868,16 +19818,10 @@ extension SwiftProtoTesting_Names_MessageNames.alignof: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._alignof {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.alignof }, fieldNumber: 1, isUnset: { $0._alignof == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.alignof, rhs: SwiftProtoTesting_Names_MessageNames.alignof) -> Bool {
     if lhs._alignof != rhs._alignof {return false}
@@ -20904,16 +19848,10 @@ extension SwiftProtoTesting_Names_MessageNames.asm: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._asm {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.asm }, fieldNumber: 1, isUnset: { $0._asm == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.asm, rhs: SwiftProtoTesting_Names_MessageNames.asm) -> Bool {
     if lhs._asm != rhs._asm {return false}
@@ -20940,16 +19878,10 @@ extension SwiftProtoTesting_Names_MessageNames.auto: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._auto {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.auto }, fieldNumber: 1, isUnset: { $0._auto == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.auto, rhs: SwiftProtoTesting_Names_MessageNames.auto) -> Bool {
     if lhs._auto != rhs._auto {return false}
@@ -20976,16 +19908,10 @@ extension SwiftProtoTesting_Names_MessageNames.bitand: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._bitand {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bitand }, fieldNumber: 1, isUnset: { $0._bitand == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bitand, rhs: SwiftProtoTesting_Names_MessageNames.bitand) -> Bool {
     if lhs._bitand != rhs._bitand {return false}
@@ -21012,16 +19938,10 @@ extension SwiftProtoTesting_Names_MessageNames.bitor: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._bitor {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bitor }, fieldNumber: 1, isUnset: { $0._bitor == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bitor, rhs: SwiftProtoTesting_Names_MessageNames.bitor) -> Bool {
     if lhs._bitor != rhs._bitor {return false}
@@ -21048,16 +19968,10 @@ extension SwiftProtoTesting_Names_MessageNames.bool: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._bool {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.bool }, fieldNumber: 1, isUnset: { $0._bool == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bool, rhs: SwiftProtoTesting_Names_MessageNames.bool) -> Bool {
     if lhs._bool != rhs._bool {return false}
@@ -21084,16 +19998,10 @@ extension SwiftProtoTesting_Names_MessageNames.char: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._char {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.char }, fieldNumber: 1, isUnset: { $0._char == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.char, rhs: SwiftProtoTesting_Names_MessageNames.char) -> Bool {
     if lhs._char != rhs._char {return false}
@@ -21120,16 +20028,10 @@ extension SwiftProtoTesting_Names_MessageNames.char16_t: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._char16T {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.char16T }, fieldNumber: 1, isUnset: { $0._char16T == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.char16_t, rhs: SwiftProtoTesting_Names_MessageNames.char16_t) -> Bool {
     if lhs._char16T != rhs._char16T {return false}
@@ -21156,16 +20058,10 @@ extension SwiftProtoTesting_Names_MessageNames.char32_t: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._char32T {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.char32T }, fieldNumber: 1, isUnset: { $0._char32T == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.char32_t, rhs: SwiftProtoTesting_Names_MessageNames.char32_t) -> Bool {
     if lhs._char32T != rhs._char32T {return false}
@@ -21192,16 +20088,10 @@ extension SwiftProtoTesting_Names_MessageNames.compl: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._compl {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.compl }, fieldNumber: 1, isUnset: { $0._compl == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.compl, rhs: SwiftProtoTesting_Names_MessageNames.compl) -> Bool {
     if lhs._compl != rhs._compl {return false}
@@ -21228,16 +20118,10 @@ extension SwiftProtoTesting_Names_MessageNames.const: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._const {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.const }, fieldNumber: 1, isUnset: { $0._const == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.const, rhs: SwiftProtoTesting_Names_MessageNames.const) -> Bool {
     if lhs._const != rhs._const {return false}
@@ -21264,16 +20148,10 @@ extension SwiftProtoTesting_Names_MessageNames.constexpr: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._constexpr {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.constexpr }, fieldNumber: 1, isUnset: { $0._constexpr == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.constexpr, rhs: SwiftProtoTesting_Names_MessageNames.constexpr) -> Bool {
     if lhs._constexpr != rhs._constexpr {return false}
@@ -21300,16 +20178,10 @@ extension SwiftProtoTesting_Names_MessageNames.const_cast: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._constCast {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.constCast }, fieldNumber: 1, isUnset: { $0._constCast == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.const_cast, rhs: SwiftProtoTesting_Names_MessageNames.const_cast) -> Bool {
     if lhs._constCast != rhs._constCast {return false}
@@ -21336,16 +20208,10 @@ extension SwiftProtoTesting_Names_MessageNames.decltype: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._decltype {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.decltype }, fieldNumber: 1, isUnset: { $0._decltype == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.decltype, rhs: SwiftProtoTesting_Names_MessageNames.decltype) -> Bool {
     if lhs._decltype != rhs._decltype {return false}
@@ -21372,16 +20238,10 @@ extension SwiftProtoTesting_Names_MessageNames.delete: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._delete {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.delete }, fieldNumber: 1, isUnset: { $0._delete == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.delete, rhs: SwiftProtoTesting_Names_MessageNames.delete) -> Bool {
     if lhs._delete != rhs._delete {return false}
@@ -21408,16 +20268,10 @@ extension SwiftProtoTesting_Names_MessageNames.dynamic_cast: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._dynamicCast {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.dynamicCast }, fieldNumber: 1, isUnset: { $0._dynamicCast == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dynamic_cast, rhs: SwiftProtoTesting_Names_MessageNames.dynamic_cast) -> Bool {
     if lhs._dynamicCast != rhs._dynamicCast {return false}
@@ -21444,16 +20298,10 @@ extension SwiftProtoTesting_Names_MessageNames.explicit: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._explicit {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.explicit }, fieldNumber: 1, isUnset: { $0._explicit == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.explicit, rhs: SwiftProtoTesting_Names_MessageNames.explicit) -> Bool {
     if lhs._explicit != rhs._explicit {return false}
@@ -21480,16 +20328,10 @@ extension SwiftProtoTesting_Names_MessageNames.export: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._export {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.export }, fieldNumber: 1, isUnset: { $0._export == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.export, rhs: SwiftProtoTesting_Names_MessageNames.export) -> Bool {
     if lhs._export != rhs._export {return false}
@@ -21516,16 +20358,10 @@ extension SwiftProtoTesting_Names_MessageNames.extern: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._extern {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extern }, fieldNumber: 1, isUnset: { $0._extern == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extern, rhs: SwiftProtoTesting_Names_MessageNames.extern) -> Bool {
     if lhs._extern != rhs._extern {return false}
@@ -21552,16 +20388,10 @@ extension SwiftProtoTesting_Names_MessageNames.friend: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._friend {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.friend }, fieldNumber: 1, isUnset: { $0._friend == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.friend, rhs: SwiftProtoTesting_Names_MessageNames.friend) -> Bool {
     if lhs._friend != rhs._friend {return false}
@@ -21588,16 +20418,10 @@ extension SwiftProtoTesting_Names_MessageNames.goto: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._goto {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.goto }, fieldNumber: 1, isUnset: { $0._goto == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.goto, rhs: SwiftProtoTesting_Names_MessageNames.goto) -> Bool {
     if lhs._goto != rhs._goto {return false}
@@ -21624,16 +20448,10 @@ extension SwiftProtoTesting_Names_MessageNames.inline: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._inline {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.inline }, fieldNumber: 1, isUnset: { $0._inline == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.inline, rhs: SwiftProtoTesting_Names_MessageNames.inline) -> Bool {
     if lhs._inline != rhs._inline {return false}
@@ -21660,16 +20478,10 @@ extension SwiftProtoTesting_Names_MessageNames.long: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._long {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.long }, fieldNumber: 1, isUnset: { $0._long == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.long, rhs: SwiftProtoTesting_Names_MessageNames.long) -> Bool {
     if lhs._long != rhs._long {return false}
@@ -21696,16 +20508,10 @@ extension SwiftProtoTesting_Names_MessageNames.mutable: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._mutable {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mutable }, fieldNumber: 1, isUnset: { $0._mutable == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.mutable, rhs: SwiftProtoTesting_Names_MessageNames.mutable) -> Bool {
     if lhs._mutable != rhs._mutable {return false}
@@ -21732,16 +20538,10 @@ extension SwiftProtoTesting_Names_MessageNames.namespace: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._namespace {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.namespace }, fieldNumber: 1, isUnset: { $0._namespace == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.namespace, rhs: SwiftProtoTesting_Names_MessageNames.namespace) -> Bool {
     if lhs._namespace != rhs._namespace {return false}
@@ -21768,16 +20568,10 @@ extension SwiftProtoTesting_Names_MessageNames.new: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._new {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.new }, fieldNumber: 1, isUnset: { $0._new == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.new, rhs: SwiftProtoTesting_Names_MessageNames.new) -> Bool {
     if lhs._new != rhs._new {return false}
@@ -21804,16 +20598,10 @@ extension SwiftProtoTesting_Names_MessageNames.noexcept: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._noexcept {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.noexcept }, fieldNumber: 1, isUnset: { $0._noexcept == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.noexcept, rhs: SwiftProtoTesting_Names_MessageNames.noexcept) -> Bool {
     if lhs._noexcept != rhs._noexcept {return false}
@@ -21840,16 +20628,10 @@ extension SwiftProtoTesting_Names_MessageNames.not: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._not {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.not }, fieldNumber: 1, isUnset: { $0._not == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.not, rhs: SwiftProtoTesting_Names_MessageNames.not) -> Bool {
     if lhs._not != rhs._not {return false}
@@ -21876,16 +20658,10 @@ extension SwiftProtoTesting_Names_MessageNames.not_eq: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._notEq {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.notEq }, fieldNumber: 1, isUnset: { $0._notEq == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.not_eq, rhs: SwiftProtoTesting_Names_MessageNames.not_eq) -> Bool {
     if lhs._notEq != rhs._notEq {return false}
@@ -21912,16 +20688,10 @@ extension SwiftProtoTesting_Names_MessageNames.nullptr: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._nullptr {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.nullptr }, fieldNumber: 1, isUnset: { $0._nullptr == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.nullptr, rhs: SwiftProtoTesting_Names_MessageNames.nullptr) -> Bool {
     if lhs._nullptr != rhs._nullptr {return false}
@@ -21948,16 +20718,10 @@ extension SwiftProtoTesting_Names_MessageNames.or: SwiftProtobuf.Message, SwiftP
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._or {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.or }, fieldNumber: 1, isUnset: { $0._or == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.or, rhs: SwiftProtoTesting_Names_MessageNames.or) -> Bool {
     if lhs._or != rhs._or {return false}
@@ -21984,16 +20748,10 @@ extension SwiftProtoTesting_Names_MessageNames.or_eq: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._orEq {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.orEq }, fieldNumber: 1, isUnset: { $0._orEq == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.or_eq, rhs: SwiftProtoTesting_Names_MessageNames.or_eq) -> Bool {
     if lhs._orEq != rhs._orEq {return false}
@@ -22020,16 +20778,10 @@ extension SwiftProtoTesting_Names_MessageNames.protected: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._protected {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protected }, fieldNumber: 1, isUnset: { $0._protected == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.protected, rhs: SwiftProtoTesting_Names_MessageNames.protected) -> Bool {
     if lhs._protected != rhs._protected {return false}
@@ -22056,16 +20808,10 @@ extension SwiftProtoTesting_Names_MessageNames.register: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._register {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.register }, fieldNumber: 1, isUnset: { $0._register == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.register, rhs: SwiftProtoTesting_Names_MessageNames.register) -> Bool {
     if lhs._register != rhs._register {return false}
@@ -22092,16 +20838,10 @@ extension SwiftProtoTesting_Names_MessageNames.reinterpret_cast: SwiftProtobuf.M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._reinterpretCast {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.reinterpretCast }, fieldNumber: 1, isUnset: { $0._reinterpretCast == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.reinterpret_cast, rhs: SwiftProtoTesting_Names_MessageNames.reinterpret_cast) -> Bool {
     if lhs._reinterpretCast != rhs._reinterpretCast {return false}
@@ -22128,16 +20868,10 @@ extension SwiftProtoTesting_Names_MessageNames.short: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._short {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.short }, fieldNumber: 1, isUnset: { $0._short == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.short, rhs: SwiftProtoTesting_Names_MessageNames.short) -> Bool {
     if lhs._short != rhs._short {return false}
@@ -22164,16 +20898,10 @@ extension SwiftProtoTesting_Names_MessageNames.signed: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._signed {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.signed }, fieldNumber: 1, isUnset: { $0._signed == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.signed, rhs: SwiftProtoTesting_Names_MessageNames.signed) -> Bool {
     if lhs._signed != rhs._signed {return false}
@@ -22200,16 +20928,10 @@ extension SwiftProtoTesting_Names_MessageNames.sizeof: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._sizeof {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sizeof }, fieldNumber: 1, isUnset: { $0._sizeof == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.sizeof, rhs: SwiftProtoTesting_Names_MessageNames.sizeof) -> Bool {
     if lhs._sizeof != rhs._sizeof {return false}
@@ -22236,16 +20958,10 @@ extension SwiftProtoTesting_Names_MessageNames.static_assert: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._staticAssert {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.staticAssert }, fieldNumber: 1, isUnset: { $0._staticAssert == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.static_assert, rhs: SwiftProtoTesting_Names_MessageNames.static_assert) -> Bool {
     if lhs._staticAssert != rhs._staticAssert {return false}
@@ -22272,16 +20988,10 @@ extension SwiftProtoTesting_Names_MessageNames.static_cast: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._staticCast {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.staticCast }, fieldNumber: 1, isUnset: { $0._staticCast == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.static_cast, rhs: SwiftProtoTesting_Names_MessageNames.static_cast) -> Bool {
     if lhs._staticCast != rhs._staticCast {return false}
@@ -22308,16 +21018,10 @@ extension SwiftProtoTesting_Names_MessageNames.template: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._template {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.template }, fieldNumber: 1, isUnset: { $0._template == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.template, rhs: SwiftProtoTesting_Names_MessageNames.template) -> Bool {
     if lhs._template != rhs._template {return false}
@@ -22344,16 +21048,10 @@ extension SwiftProtoTesting_Names_MessageNames.this: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._this {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.this }, fieldNumber: 1, isUnset: { $0._this == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.this, rhs: SwiftProtoTesting_Names_MessageNames.this) -> Bool {
     if lhs._this != rhs._this {return false}
@@ -22380,16 +21078,10 @@ extension SwiftProtoTesting_Names_MessageNames.thread_local: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._threadLocal {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.threadLocal }, fieldNumber: 1, isUnset: { $0._threadLocal == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.thread_local, rhs: SwiftProtoTesting_Names_MessageNames.thread_local) -> Bool {
     if lhs._threadLocal != rhs._threadLocal {return false}
@@ -22416,16 +21108,10 @@ extension SwiftProtoTesting_Names_MessageNames.typedef: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._typedef {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.typedef }, fieldNumber: 1, isUnset: { $0._typedef == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typedef, rhs: SwiftProtoTesting_Names_MessageNames.typedef) -> Bool {
     if lhs._typedef != rhs._typedef {return false}
@@ -22452,16 +21138,10 @@ extension SwiftProtoTesting_Names_MessageNames.typeid: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._typeid {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.typeid }, fieldNumber: 1, isUnset: { $0._typeid == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typeid, rhs: SwiftProtoTesting_Names_MessageNames.typeid) -> Bool {
     if lhs._typeid != rhs._typeid {return false}
@@ -22488,16 +21168,10 @@ extension SwiftProtoTesting_Names_MessageNames.typename: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._typename {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.typename }, fieldNumber: 1, isUnset: { $0._typename == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typename, rhs: SwiftProtoTesting_Names_MessageNames.typename) -> Bool {
     if lhs._typename != rhs._typename {return false}
@@ -22524,16 +21198,10 @@ extension SwiftProtoTesting_Names_MessageNames.union: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._union {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.union }, fieldNumber: 1, isUnset: { $0._union == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.union, rhs: SwiftProtoTesting_Names_MessageNames.union) -> Bool {
     if lhs._union != rhs._union {return false}
@@ -22560,16 +21228,10 @@ extension SwiftProtoTesting_Names_MessageNames.unsigned: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._unsigned {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unsigned }, fieldNumber: 1, isUnset: { $0._unsigned == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.unsigned, rhs: SwiftProtoTesting_Names_MessageNames.unsigned) -> Bool {
     if lhs._unsigned != rhs._unsigned {return false}
@@ -22596,16 +21258,10 @@ extension SwiftProtoTesting_Names_MessageNames.using: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._using {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.using }, fieldNumber: 1, isUnset: { $0._using == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.using, rhs: SwiftProtoTesting_Names_MessageNames.using) -> Bool {
     if lhs._using != rhs._using {return false}
@@ -22632,16 +21288,10 @@ extension SwiftProtoTesting_Names_MessageNames.virtual: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._virtual {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.virtual }, fieldNumber: 1, isUnset: { $0._virtual == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.virtual, rhs: SwiftProtoTesting_Names_MessageNames.virtual) -> Bool {
     if lhs._virtual != rhs._virtual {return false}
@@ -22668,16 +21318,10 @@ extension SwiftProtoTesting_Names_MessageNames.void: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._void {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.void }, fieldNumber: 1, isUnset: { $0._void == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.void, rhs: SwiftProtoTesting_Names_MessageNames.void) -> Bool {
     if lhs._void != rhs._void {return false}
@@ -22704,16 +21348,10 @@ extension SwiftProtoTesting_Names_MessageNames.volatile: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._volatile {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.volatile }, fieldNumber: 1, isUnset: { $0._volatile == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.volatile, rhs: SwiftProtoTesting_Names_MessageNames.volatile) -> Bool {
     if lhs._volatile != rhs._volatile {return false}
@@ -22740,16 +21378,10 @@ extension SwiftProtoTesting_Names_MessageNames.wchar_t: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._wcharT {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.wcharT }, fieldNumber: 1, isUnset: { $0._wcharT == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.wchar_t, rhs: SwiftProtoTesting_Names_MessageNames.wchar_t) -> Bool {
     if lhs._wcharT != rhs._wcharT {return false}
@@ -22776,16 +21408,10 @@ extension SwiftProtoTesting_Names_MessageNames.xor: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._xor {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.xor }, fieldNumber: 1, isUnset: { $0._xor == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.xor, rhs: SwiftProtoTesting_Names_MessageNames.xor) -> Bool {
     if lhs._xor != rhs._xor {return false}
@@ -22812,16 +21438,10 @@ extension SwiftProtoTesting_Names_MessageNames.xor_eq: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._xorEq {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.xorEq }, fieldNumber: 1, isUnset: { $0._xorEq == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.xor_eq, rhs: SwiftProtoTesting_Names_MessageNames.xor_eq) -> Bool {
     if lhs._xorEq != rhs._xorEq {return false}
@@ -22848,16 +21468,10 @@ extension SwiftProtoTesting_Names_MessageNames.restrict: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._restrict {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.restrict }, fieldNumber: 1, isUnset: { $0._restrict == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.restrict, rhs: SwiftProtoTesting_Names_MessageNames.restrict) -> Bool {
     if lhs._restrict != rhs._restrict {return false}
@@ -22884,16 +21498,10 @@ extension SwiftProtoTesting_Names_MessageNames.Category: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._category {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.category }, fieldNumber: 1, isUnset: { $0._category == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Category, rhs: SwiftProtoTesting_Names_MessageNames.Category) -> Bool {
     if lhs._category != rhs._category {return false}
@@ -22920,16 +21528,10 @@ extension SwiftProtoTesting_Names_MessageNames.Ivar: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._ivar {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.ivar }, fieldNumber: 1, isUnset: { $0._ivar == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Ivar, rhs: SwiftProtoTesting_Names_MessageNames.Ivar) -> Bool {
     if lhs._ivar != rhs._ivar {return false}
@@ -22956,16 +21558,10 @@ extension SwiftProtoTesting_Names_MessageNames.Method: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._method {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.method }, fieldNumber: 1, isUnset: { $0._method == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Method, rhs: SwiftProtoTesting_Names_MessageNames.Method) -> Bool {
     if lhs._method != rhs._method {return false}
@@ -22992,16 +21588,10 @@ extension SwiftProtoTesting_Names_MessageNames.finalize: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._finalize {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.finalize }, fieldNumber: 1, isUnset: { $0._finalize == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.finalize, rhs: SwiftProtoTesting_Names_MessageNames.finalize) -> Bool {
     if lhs._finalize != rhs._finalize {return false}
@@ -23028,16 +21618,10 @@ extension SwiftProtoTesting_Names_MessageNames.hash: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._hash {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.hash }, fieldNumber: 1, isUnset: { $0._hash == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.hash, rhs: SwiftProtoTesting_Names_MessageNames.hash) -> Bool {
     if lhs._hash != rhs._hash {return false}
@@ -23064,16 +21648,10 @@ extension SwiftProtoTesting_Names_MessageNames.dealloc: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._dealloc {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.dealloc }, fieldNumber: 1, isUnset: { $0._dealloc == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dealloc, rhs: SwiftProtoTesting_Names_MessageNames.dealloc) -> Bool {
     if lhs._dealloc != rhs._dealloc {return false}
@@ -23100,16 +21678,10 @@ extension SwiftProtoTesting_Names_MessageNames.superclass: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._superclass {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.superclass }, fieldNumber: 1, isUnset: { $0._superclass == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.superclass, rhs: SwiftProtoTesting_Names_MessageNames.superclass) -> Bool {
     if lhs._superclass != rhs._superclass {return false}
@@ -23136,16 +21708,10 @@ extension SwiftProtoTesting_Names_MessageNames.retain: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._retain {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.retain }, fieldNumber: 1, isUnset: { $0._retain == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.retain, rhs: SwiftProtoTesting_Names_MessageNames.retain) -> Bool {
     if lhs._retain != rhs._retain {return false}
@@ -23172,16 +21738,10 @@ extension SwiftProtoTesting_Names_MessageNames.release: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._release {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.release }, fieldNumber: 1, isUnset: { $0._release == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.release, rhs: SwiftProtoTesting_Names_MessageNames.release) -> Bool {
     if lhs._release != rhs._release {return false}
@@ -23208,16 +21768,10 @@ extension SwiftProtoTesting_Names_MessageNames.autorelease: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._autorelease {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.autorelease }, fieldNumber: 1, isUnset: { $0._autorelease == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.autorelease, rhs: SwiftProtoTesting_Names_MessageNames.autorelease) -> Bool {
     if lhs._autorelease != rhs._autorelease {return false}
@@ -23244,16 +21798,10 @@ extension SwiftProtoTesting_Names_MessageNames.retainCount: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._retainCount {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.retainCount }, fieldNumber: 1, isUnset: { $0._retainCount == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.retainCount, rhs: SwiftProtoTesting_Names_MessageNames.retainCount) -> Bool {
     if lhs._retainCount != rhs._retainCount {return false}
@@ -23280,16 +21828,10 @@ extension SwiftProtoTesting_Names_MessageNames.zone: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._zone {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.zone }, fieldNumber: 1, isUnset: { $0._zone == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.zone, rhs: SwiftProtoTesting_Names_MessageNames.zone) -> Bool {
     if lhs._zone != rhs._zone {return false}
@@ -23316,16 +21858,10 @@ extension SwiftProtoTesting_Names_MessageNames.isProxy: SwiftProtobuf.Message, S
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._isProxy {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isProxy }, fieldNumber: 1, isUnset: { $0._isProxy == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.isProxy, rhs: SwiftProtoTesting_Names_MessageNames.isProxy) -> Bool {
     if lhs._isProxy != rhs._isProxy {return false}
@@ -23352,16 +21888,10 @@ extension SwiftProtoTesting_Names_MessageNames.copy: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._copy {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.copy }, fieldNumber: 1, isUnset: { $0._copy == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.copy, rhs: SwiftProtoTesting_Names_MessageNames.copy) -> Bool {
     if lhs._copy != rhs._copy {return false}
@@ -23388,16 +21918,10 @@ extension SwiftProtoTesting_Names_MessageNames.mutableCopy: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._mutableCopy {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.mutableCopy }, fieldNumber: 1, isUnset: { $0._mutableCopy == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.mutableCopy, rhs: SwiftProtoTesting_Names_MessageNames.mutableCopy) -> Bool {
     if lhs._mutableCopy != rhs._mutableCopy {return false}
@@ -23424,16 +21948,10 @@ extension SwiftProtoTesting_Names_MessageNames.classForCoder: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._classForCoder {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.classForCoder }, fieldNumber: 1, isUnset: { $0._classForCoder == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.classForCoder, rhs: SwiftProtoTesting_Names_MessageNames.classForCoder) -> Bool {
     if lhs._classForCoder != rhs._classForCoder {return false}
@@ -23460,16 +21978,10 @@ extension SwiftProtoTesting_Names_MessageNames.clear: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._clear {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.clear }, fieldNumber: 1, isUnset: { $0._clear == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.clear, rhs: SwiftProtoTesting_Names_MessageNames.clear) -> Bool {
     if lhs._clear != rhs._clear {return false}
@@ -23496,16 +22008,10 @@ extension SwiftProtoTesting_Names_MessageNames.data: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._data {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.data }, fieldNumber: 1, isUnset: { $0._data == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.data, rhs: SwiftProtoTesting_Names_MessageNames.data) -> Bool {
     if lhs._data != rhs._data {return false}
@@ -23532,16 +22038,10 @@ extension SwiftProtoTesting_Names_MessageNames.delimitedData: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._delimitedData {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.delimitedData }, fieldNumber: 1, isUnset: { $0._delimitedData == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.delimitedData, rhs: SwiftProtoTesting_Names_MessageNames.delimitedData) -> Bool {
     if lhs._delimitedData != rhs._delimitedData {return false}
@@ -23568,16 +22068,10 @@ extension SwiftProtoTesting_Names_MessageNames.descriptor: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._descriptor {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.descriptor }, fieldNumber: 1, isUnset: { $0._descriptor == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.descriptor, rhs: SwiftProtoTesting_Names_MessageNames.descriptor) -> Bool {
     if lhs._descriptor != rhs._descriptor {return false}
@@ -23604,16 +22098,10 @@ extension SwiftProtoTesting_Names_MessageNames.extensionRegistry: SwiftProtobuf.
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._extensionRegistry {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensionRegistry }, fieldNumber: 1, isUnset: { $0._extensionRegistry == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extensionRegistry, rhs: SwiftProtoTesting_Names_MessageNames.extensionRegistry) -> Bool {
     if lhs._extensionRegistry != rhs._extensionRegistry {return false}
@@ -23640,16 +22128,10 @@ extension SwiftProtoTesting_Names_MessageNames.extensionsCurrentlySet: SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._extensionsCurrentlySet {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensionsCurrentlySet }, fieldNumber: 1, isUnset: { $0._extensionsCurrentlySet == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extensionsCurrentlySet, rhs: SwiftProtoTesting_Names_MessageNames.extensionsCurrentlySet) -> Bool {
     if lhs._extensionsCurrentlySet != rhs._extensionsCurrentlySet {return false}
@@ -23676,16 +22158,10 @@ extension SwiftProtoTesting_Names_MessageNames.isInitializedMessage: SwiftProtob
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._isInitialized_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isInitialized_p }, fieldNumber: 1, isUnset: { $0._isInitialized_p == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.isInitializedMessage, rhs: SwiftProtoTesting_Names_MessageNames.isInitializedMessage) -> Bool {
     if lhs._isInitialized_p != rhs._isInitialized_p {return false}
@@ -23712,16 +22188,10 @@ extension SwiftProtoTesting_Names_MessageNames.serializedSize: SwiftProtobuf.Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._serializedSize {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.serializedSize }, fieldNumber: 1, isUnset: { $0._serializedSize == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.serializedSize, rhs: SwiftProtoTesting_Names_MessageNames.serializedSize) -> Bool {
     if lhs._serializedSize != rhs._serializedSize {return false}
@@ -23748,16 +22218,10 @@ extension SwiftProtoTesting_Names_MessageNames.sortedExtensionsInUse: SwiftProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._sortedExtensionsInUse {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.sortedExtensionsInUse }, fieldNumber: 1, isUnset: { $0._sortedExtensionsInUse == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.sortedExtensionsInUse, rhs: SwiftProtoTesting_Names_MessageNames.sortedExtensionsInUse) -> Bool {
     if lhs._sortedExtensionsInUse != rhs._sortedExtensionsInUse {return false}
@@ -23784,16 +22248,10 @@ extension SwiftProtoTesting_Names_MessageNames.unknownFieldsMessage: SwiftProtob
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._unknownFields_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.unknownFields_p }, fieldNumber: 1, isUnset: { $0._unknownFields_p == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.unknownFieldsMessage, rhs: SwiftProtoTesting_Names_MessageNames.unknownFieldsMessage) -> Bool {
     if lhs._unknownFields_p != rhs._unknownFields_p {return false}
@@ -23820,16 +22278,10 @@ extension SwiftProtoTesting_Names_MessageNames.Fixed: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._fixed {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fixed }, fieldNumber: 1, isUnset: { $0._fixed == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Fixed, rhs: SwiftProtoTesting_Names_MessageNames.Fixed) -> Bool {
     if lhs._fixed != rhs._fixed {return false}
@@ -23856,16 +22308,10 @@ extension SwiftProtoTesting_Names_MessageNames.Fract: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._fract {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fract }, fieldNumber: 1, isUnset: { $0._fract == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Fract, rhs: SwiftProtoTesting_Names_MessageNames.Fract) -> Bool {
     if lhs._fract != rhs._fract {return false}
@@ -23892,16 +22338,10 @@ extension SwiftProtoTesting_Names_MessageNames.Size: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._size {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.size }, fieldNumber: 1, isUnset: { $0._size == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Size, rhs: SwiftProtoTesting_Names_MessageNames.Size) -> Bool {
     if lhs._size != rhs._size {return false}
@@ -23928,16 +22368,10 @@ extension SwiftProtoTesting_Names_MessageNames.LogicalAddress: SwiftProtobuf.Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._logicalAddress {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.logicalAddress }, fieldNumber: 1, isUnset: { $0._logicalAddress == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.LogicalAddress, rhs: SwiftProtoTesting_Names_MessageNames.LogicalAddress) -> Bool {
     if lhs._logicalAddress != rhs._logicalAddress {return false}
@@ -23964,16 +22398,10 @@ extension SwiftProtoTesting_Names_MessageNames.PhysicalAddress: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._physicalAddress {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.physicalAddress }, fieldNumber: 1, isUnset: { $0._physicalAddress == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.PhysicalAddress, rhs: SwiftProtoTesting_Names_MessageNames.PhysicalAddress) -> Bool {
     if lhs._physicalAddress != rhs._physicalAddress {return false}
@@ -24000,16 +22428,10 @@ extension SwiftProtoTesting_Names_MessageNames.ByteCount: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._byteCount {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.byteCount }, fieldNumber: 1, isUnset: { $0._byteCount == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ByteCount, rhs: SwiftProtoTesting_Names_MessageNames.ByteCount) -> Bool {
     if lhs._byteCount != rhs._byteCount {return false}
@@ -24036,16 +22458,10 @@ extension SwiftProtoTesting_Names_MessageNames.ByteOffset: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._byteOffset {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.byteOffset }, fieldNumber: 1, isUnset: { $0._byteOffset == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ByteOffset, rhs: SwiftProtoTesting_Names_MessageNames.ByteOffset) -> Bool {
     if lhs._byteOffset != rhs._byteOffset {return false}
@@ -24072,16 +22488,10 @@ extension SwiftProtoTesting_Names_MessageNames.Duration: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._duration {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.duration }, fieldNumber: 1, isUnset: { $0._duration == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Duration, rhs: SwiftProtoTesting_Names_MessageNames.Duration) -> Bool {
     if lhs._duration != rhs._duration {return false}
@@ -24108,16 +22518,10 @@ extension SwiftProtoTesting_Names_MessageNames.AbsoluteTime: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._absoluteTime {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.absoluteTime }, fieldNumber: 1, isUnset: { $0._absoluteTime == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.AbsoluteTime, rhs: SwiftProtoTesting_Names_MessageNames.AbsoluteTime) -> Bool {
     if lhs._absoluteTime != rhs._absoluteTime {return false}
@@ -24144,16 +22548,10 @@ extension SwiftProtoTesting_Names_MessageNames.OptionBits: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._optionBits {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionBits }, fieldNumber: 1, isUnset: { $0._optionBits == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.OptionBits, rhs: SwiftProtoTesting_Names_MessageNames.OptionBits) -> Bool {
     if lhs._optionBits != rhs._optionBits {return false}
@@ -24180,16 +22578,10 @@ extension SwiftProtoTesting_Names_MessageNames.ItemCount: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._itemCount {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.itemCount }, fieldNumber: 1, isUnset: { $0._itemCount == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ItemCount, rhs: SwiftProtoTesting_Names_MessageNames.ItemCount) -> Bool {
     if lhs._itemCount != rhs._itemCount {return false}
@@ -24216,16 +22608,10 @@ extension SwiftProtoTesting_Names_MessageNames.PBVersion: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._pbversion {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.pbversion }, fieldNumber: 1, isUnset: { $0._pbversion == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.PBVersion, rhs: SwiftProtoTesting_Names_MessageNames.PBVersion) -> Bool {
     if lhs._pbversion != rhs._pbversion {return false}
@@ -24252,16 +22638,10 @@ extension SwiftProtoTesting_Names_MessageNames.ScriptCode: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._scriptCode {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.scriptCode }, fieldNumber: 1, isUnset: { $0._scriptCode == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ScriptCode, rhs: SwiftProtoTesting_Names_MessageNames.ScriptCode) -> Bool {
     if lhs._scriptCode != rhs._scriptCode {return false}
@@ -24288,16 +22668,10 @@ extension SwiftProtoTesting_Names_MessageNames.LangCode: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._langCode {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.langCode }, fieldNumber: 1, isUnset: { $0._langCode == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.LangCode, rhs: SwiftProtoTesting_Names_MessageNames.LangCode) -> Bool {
     if lhs._langCode != rhs._langCode {return false}
@@ -24324,16 +22698,10 @@ extension SwiftProtoTesting_Names_MessageNames.RegionCode: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._regionCode {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.regionCode }, fieldNumber: 1, isUnset: { $0._regionCode == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.RegionCode, rhs: SwiftProtoTesting_Names_MessageNames.RegionCode) -> Bool {
     if lhs._regionCode != rhs._regionCode {return false}
@@ -24360,16 +22728,10 @@ extension SwiftProtoTesting_Names_MessageNames.OSType: SwiftProtobuf.Message, Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._ostype {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.ostype }, fieldNumber: 1, isUnset: { $0._ostype == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.OSType, rhs: SwiftProtoTesting_Names_MessageNames.OSType) -> Bool {
     if lhs._ostype != rhs._ostype {return false}
@@ -24396,16 +22758,10 @@ extension SwiftProtoTesting_Names_MessageNames.ProcessSerialNumber: SwiftProtobu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._processSerialNumber {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.processSerialNumber }, fieldNumber: 1, isUnset: { $0._processSerialNumber == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ProcessSerialNumber, rhs: SwiftProtoTesting_Names_MessageNames.ProcessSerialNumber) -> Bool {
     if lhs._processSerialNumber != rhs._processSerialNumber {return false}
@@ -24432,16 +22788,10 @@ extension SwiftProtoTesting_Names_MessageNames.Point: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._point {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.point }, fieldNumber: 1, isUnset: { $0._point == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Point, rhs: SwiftProtoTesting_Names_MessageNames.Point) -> Bool {
     if lhs._point != rhs._point {return false}
@@ -24468,16 +22818,10 @@ extension SwiftProtoTesting_Names_MessageNames.Rect: SwiftProtobuf.Message, Swif
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._rect {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.rect }, fieldNumber: 1, isUnset: { $0._rect == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Rect, rhs: SwiftProtoTesting_Names_MessageNames.Rect) -> Bool {
     if lhs._rect != rhs._rect {return false}
@@ -24504,16 +22848,10 @@ extension SwiftProtoTesting_Names_MessageNames.FixedPoint: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._fixedPoint {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fixedPoint }, fieldNumber: 1, isUnset: { $0._fixedPoint == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.FixedPoint, rhs: SwiftProtoTesting_Names_MessageNames.FixedPoint) -> Bool {
     if lhs._fixedPoint != rhs._fixedPoint {return false}
@@ -24540,16 +22878,10 @@ extension SwiftProtoTesting_Names_MessageNames.FixedRect: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._fixedRect {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.fixedRect }, fieldNumber: 1, isUnset: { $0._fixedRect == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.FixedRect, rhs: SwiftProtoTesting_Names_MessageNames.FixedRect) -> Bool {
     if lhs._fixedRect != rhs._fixedRect {return false}
@@ -24576,16 +22908,10 @@ extension SwiftProtoTesting_Names_MessageNames.Style: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._style {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.style }, fieldNumber: 1, isUnset: { $0._style == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Style, rhs: SwiftProtoTesting_Names_MessageNames.Style) -> Bool {
     if lhs._style != rhs._style {return false}
@@ -24612,16 +22938,10 @@ extension SwiftProtoTesting_Names_MessageNames.StyleParameter: SwiftProtobuf.Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._styleParameter {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.styleParameter }, fieldNumber: 1, isUnset: { $0._styleParameter == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.StyleParameter, rhs: SwiftProtoTesting_Names_MessageNames.StyleParameter) -> Bool {
     if lhs._styleParameter != rhs._styleParameter {return false}
@@ -24648,16 +22968,10 @@ extension SwiftProtoTesting_Names_MessageNames.StyleField: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._styleField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.styleField }, fieldNumber: 1, isUnset: { $0._styleField == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.StyleField, rhs: SwiftProtoTesting_Names_MessageNames.StyleField) -> Bool {
     if lhs._styleField != rhs._styleField {return false}
@@ -24684,16 +22998,10 @@ extension SwiftProtoTesting_Names_MessageNames.TimeScale: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._timeScale {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.timeScale }, fieldNumber: 1, isUnset: { $0._timeScale == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TimeScale, rhs: SwiftProtoTesting_Names_MessageNames.TimeScale) -> Bool {
     if lhs._timeScale != rhs._timeScale {return false}
@@ -24720,16 +23028,10 @@ extension SwiftProtoTesting_Names_MessageNames.TimeBase: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._timeBase {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.timeBase }, fieldNumber: 1, isUnset: { $0._timeBase == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TimeBase, rhs: SwiftProtoTesting_Names_MessageNames.TimeBase) -> Bool {
     if lhs._timeBase != rhs._timeBase {return false}
@@ -24756,16 +23058,10 @@ extension SwiftProtoTesting_Names_MessageNames.TimeRecord: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._timeRecord {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.timeRecord }, fieldNumber: 1, isUnset: { $0._timeRecord == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TimeRecord, rhs: SwiftProtoTesting_Names_MessageNames.TimeRecord) -> Bool {
     if lhs._timeRecord != rhs._timeRecord {return false}
@@ -24792,16 +23088,10 @@ extension SwiftProtoTesting_Names_MessageNames.serializedData: SwiftProtobuf.Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._serializedData {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.serializedData }, fieldNumber: 1, isUnset: { $0._serializedData == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.serializedData, rhs: SwiftProtoTesting_Names_MessageNames.serializedData) -> Bool {
     if lhs._serializedData != rhs._serializedData {return false}
@@ -24828,16 +23118,10 @@ extension SwiftProtoTesting_Names_MessageNames.jsonUTF8Data: SwiftProtobuf.Messa
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._jsonUtf8Data {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonUtf8Data }, fieldNumber: 1, isUnset: { $0._jsonUtf8Data == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.jsonUTF8Data, rhs: SwiftProtoTesting_Names_MessageNames.jsonUTF8Data) -> Bool {
     if lhs._jsonUtf8Data != rhs._jsonUtf8Data {return false}
@@ -24864,16 +23148,10 @@ extension SwiftProtoTesting_Names_MessageNames.jsonString: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._jsonString {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.jsonString }, fieldNumber: 1, isUnset: { $0._jsonString == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.jsonString, rhs: SwiftProtoTesting_Names_MessageNames.jsonString) -> Bool {
     if lhs._jsonString != rhs._jsonString {return false}
@@ -24900,16 +23178,10 @@ extension SwiftProtoTesting_Names_MessageNames.Extension: SwiftProtobuf.Message,
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._extension {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.`extension` }, fieldNumber: 1, isUnset: { $0._extension == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Extension, rhs: SwiftProtoTesting_Names_MessageNames.Extension) -> Bool {
     if lhs._extension != rhs._extension {return false}
@@ -24936,16 +23208,10 @@ extension SwiftProtoTesting_Names_MessageNames.ExtensionsMessage: SwiftProtobuf.
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._extensions {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.extensions }, fieldNumber: 1, isUnset: { $0._extensions == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ExtensionsMessage, rhs: SwiftProtoTesting_Names_MessageNames.ExtensionsMessage) -> Bool {
     if lhs._extensions != rhs._extensions {return false}
@@ -24963,9 +23229,9 @@ extension SwiftProtoTesting_Names_EnumNames: SwiftProtobuf.Message, SwiftProtobu
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_EnumNames, rhs: SwiftProtoTesting_Names_EnumNames) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -26248,9 +24514,9 @@ extension SwiftProtoTesting_Names_FieldNamingInitials: SwiftProtobuf.Message, Sw
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials, rhs: SwiftProtoTesting_Names_FieldNamingInitials) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -26362,66 +24628,26 @@ extension SwiftProtoTesting_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._http {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._httpRequest {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._theHTTPRequest {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._theHTTP {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._https {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._httpsRequest {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._theHTTPSRequest {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._theHTTPS {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._url {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 21)
-      } }()
-      try { if let v = _storage._urlValue {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 22)
-      } }()
-      try { if let v = _storage._theURLValue {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 23)
-      } }()
-      try { if let v = _storage._theURL {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 24)
-      } }()
-      try { if let v = _storage._aBC {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 31)
-      } }()
-      try { if let v = _storage._id {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 41)
-      } }()
-      try { if let v = _storage._idNumber {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 42)
-      } }()
-      try { if let v = _storage._theIDNumber {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 43)
-      } }()
-      try { if let v = _storage._requestID {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 44)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.http }, fieldNumber: 1, isUnset: { $0._storage._http == nil }),
+    .singularInt32({ $0.httpRequest }, fieldNumber: 2, isUnset: { $0._storage._httpRequest == nil }),
+    .singularInt32({ $0.theHTTPRequest }, fieldNumber: 3, isUnset: { $0._storage._theHTTPRequest == nil }),
+    .singularInt32({ $0.theHTTP }, fieldNumber: 4, isUnset: { $0._storage._theHTTP == nil }),
+    .singularInt32({ $0.https }, fieldNumber: 11, isUnset: { $0._storage._https == nil }),
+    .singularInt32({ $0.httpsRequest }, fieldNumber: 12, isUnset: { $0._storage._httpsRequest == nil }),
+    .singularInt32({ $0.theHTTPSRequest }, fieldNumber: 13, isUnset: { $0._storage._theHTTPSRequest == nil }),
+    .singularInt32({ $0.theHTTPS }, fieldNumber: 14, isUnset: { $0._storage._theHTTPS == nil }),
+    .singularInt32({ $0.url }, fieldNumber: 21, isUnset: { $0._storage._url == nil }),
+    .singularInt32({ $0.urlValue }, fieldNumber: 22, isUnset: { $0._storage._urlValue == nil }),
+    .singularInt32({ $0.theURLValue }, fieldNumber: 23, isUnset: { $0._storage._theURLValue == nil }),
+    .singularInt32({ $0.theURL }, fieldNumber: 24, isUnset: { $0._storage._theURL == nil }),
+    .singularInt32({ $0.aBC }, fieldNumber: 31, isUnset: { $0._storage._aBC == nil }),
+    .singularInt32({ $0.id }, fieldNumber: 41, isUnset: { $0._storage._id == nil }),
+    .singularInt32({ $0.idNumber }, fieldNumber: 42, isUnset: { $0._storage._idNumber == nil }),
+    .singularInt32({ $0.theIDNumber }, fieldNumber: 43, isUnset: { $0._storage._theIDNumber == nil }),
+    .singularInt32({ $0.requestID }, fieldNumber: 44, isUnset: { $0._storage._requestID == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials.Lowers, rhs: SwiftProtoTesting_Names_FieldNamingInitials.Lowers) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -26502,61 +24728,25 @@ extension SwiftProtoTesting_Names_FieldNamingInitials.Uppers: SwiftProtobuf.Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._http {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._httpRequest {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._theHTTPRequest {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._theHTTP {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 4)
-    } }()
-    try { if let v = self._https {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 11)
-    } }()
-    try { if let v = self._httpsRequest {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 12)
-    } }()
-    try { if let v = self._theHTTPSRequest {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 13)
-    } }()
-    try { if let v = self._theHTTPS {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 14)
-    } }()
-    try { if let v = self._url {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 21)
-    } }()
-    try { if let v = self._urlValue {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 22)
-    } }()
-    try { if let v = self._theURLValue {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 23)
-    } }()
-    try { if let v = self._theURL {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 24)
-    } }()
-    try { if let v = self._id {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 41)
-    } }()
-    try { if let v = self._idNumber {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 42)
-    } }()
-    try { if let v = self._theIDNumber {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 43)
-    } }()
-    try { if let v = self._requestID {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 44)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.http }, fieldNumber: 1, isUnset: { $0._http == nil }),
+    .singularInt32({ $0.httpRequest }, fieldNumber: 2, isUnset: { $0._httpRequest == nil }),
+    .singularInt32({ $0.theHTTPRequest }, fieldNumber: 3, isUnset: { $0._theHTTPRequest == nil }),
+    .singularInt32({ $0.theHTTP }, fieldNumber: 4, isUnset: { $0._theHTTP == nil }),
+    .singularInt32({ $0.https }, fieldNumber: 11, isUnset: { $0._https == nil }),
+    .singularInt32({ $0.httpsRequest }, fieldNumber: 12, isUnset: { $0._httpsRequest == nil }),
+    .singularInt32({ $0.theHTTPSRequest }, fieldNumber: 13, isUnset: { $0._theHTTPSRequest == nil }),
+    .singularInt32({ $0.theHTTPS }, fieldNumber: 14, isUnset: { $0._theHTTPS == nil }),
+    .singularInt32({ $0.url }, fieldNumber: 21, isUnset: { $0._url == nil }),
+    .singularInt32({ $0.urlValue }, fieldNumber: 22, isUnset: { $0._urlValue == nil }),
+    .singularInt32({ $0.theURLValue }, fieldNumber: 23, isUnset: { $0._theURLValue == nil }),
+    .singularInt32({ $0.theURL }, fieldNumber: 24, isUnset: { $0._theURL == nil }),
+    .singularInt32({ $0.id }, fieldNumber: 41, isUnset: { $0._id == nil }),
+    .singularInt32({ $0.idNumber }, fieldNumber: 42, isUnset: { $0._idNumber == nil }),
+    .singularInt32({ $0.theIDNumber }, fieldNumber: 43, isUnset: { $0._theIDNumber == nil }),
+    .singularInt32({ $0.requestID }, fieldNumber: 44, isUnset: { $0._requestID == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials.Uppers, rhs: SwiftProtoTesting_Names_FieldNamingInitials.Uppers) -> Bool {
     if lhs._http != rhs._http {return false}
@@ -26628,61 +24818,25 @@ extension SwiftProtoTesting_Names_FieldNamingInitials.WordCase: SwiftProtobuf.Me
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._http {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._httpRequest {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._theHTTPRequest {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-    } }()
-    try { if let v = self._theHTTP {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 4)
-    } }()
-    try { if let v = self._https {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 11)
-    } }()
-    try { if let v = self._httpsRequest {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 12)
-    } }()
-    try { if let v = self._theHTTPSRequest {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 13)
-    } }()
-    try { if let v = self._theHTTPS {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 14)
-    } }()
-    try { if let v = self._url {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 21)
-    } }()
-    try { if let v = self._urlValue {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 22)
-    } }()
-    try { if let v = self._theURLValue {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 23)
-    } }()
-    try { if let v = self._theURL {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 24)
-    } }()
-    try { if let v = self._id {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 41)
-    } }()
-    try { if let v = self._idNumber {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 42)
-    } }()
-    try { if let v = self._theIDNumber {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 43)
-    } }()
-    try { if let v = self._requestID {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 44)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.http }, fieldNumber: 1, isUnset: { $0._http == nil }),
+    .singularInt32({ $0.httpRequest }, fieldNumber: 2, isUnset: { $0._httpRequest == nil }),
+    .singularInt32({ $0.theHTTPRequest }, fieldNumber: 3, isUnset: { $0._theHTTPRequest == nil }),
+    .singularInt32({ $0.theHTTP }, fieldNumber: 4, isUnset: { $0._theHTTP == nil }),
+    .singularInt32({ $0.https }, fieldNumber: 11, isUnset: { $0._https == nil }),
+    .singularInt32({ $0.httpsRequest }, fieldNumber: 12, isUnset: { $0._httpsRequest == nil }),
+    .singularInt32({ $0.theHTTPSRequest }, fieldNumber: 13, isUnset: { $0._theHTTPSRequest == nil }),
+    .singularInt32({ $0.theHTTPS }, fieldNumber: 14, isUnset: { $0._theHTTPS == nil }),
+    .singularInt32({ $0.url }, fieldNumber: 21, isUnset: { $0._url == nil }),
+    .singularInt32({ $0.urlValue }, fieldNumber: 22, isUnset: { $0._urlValue == nil }),
+    .singularInt32({ $0.theURLValue }, fieldNumber: 23, isUnset: { $0._theURLValue == nil }),
+    .singularInt32({ $0.theURL }, fieldNumber: 24, isUnset: { $0._theURL == nil }),
+    .singularInt32({ $0.id }, fieldNumber: 41, isUnset: { $0._id == nil }),
+    .singularInt32({ $0.idNumber }, fieldNumber: 42, isUnset: { $0._idNumber == nil }),
+    .singularInt32({ $0.theIDNumber }, fieldNumber: 43, isUnset: { $0._theIDNumber == nil }),
+    .singularInt32({ $0.requestID }, fieldNumber: 44, isUnset: { $0._requestID == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials.WordCase, rhs: SwiftProtoTesting_Names_FieldNamingInitials.WordCase) -> Bool {
     if lhs._http != rhs._http {return false}
@@ -26723,10 +24877,10 @@ extension SwiftProtoTesting_Names_ExtensionNamingInitials: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 1001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1, end: 1001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitials, rhs: SwiftProtoTesting_Names_ExtensionNamingInitials) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -26744,9 +24898,9 @@ extension SwiftProtoTesting_Names_Lowers: SwiftProtobuf.Message, SwiftProtobuf._
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_Lowers, rhs: SwiftProtoTesting_Names_Lowers) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -26763,9 +24917,9 @@ extension SwiftProtoTesting_Names_Uppers: SwiftProtobuf.Message, SwiftProtobuf._
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_Uppers, rhs: SwiftProtoTesting_Names_Uppers) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -26782,9 +24936,9 @@ extension SwiftProtoTesting_Names_WordCase: SwiftProtobuf.Message, SwiftProtobuf
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_WordCase, rhs: SwiftProtoTesting_Names_WordCase) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -26809,10 +24963,10 @@ extension SwiftProtoTesting_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 1001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1, end: 1001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitialsLowers, rhs: SwiftProtoTesting_Names_ExtensionNamingInitialsLowers) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -26838,10 +24992,10 @@ extension SwiftProtoTesting_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.M
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 1001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1, end: 1001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitialsUppers, rhs: SwiftProtoTesting_Names_ExtensionNamingInitialsUppers) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -26867,10 +25021,10 @@ extension SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 1001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1, end: 1001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase, rhs: SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -26921,36 +25075,23 @@ extension SwiftProtoTesting_Names_ValidIdentifiers: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self.__1Field {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._field {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self.__3Field3 {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-    } }()
-    switch self._2Of {
-    case ._4?: try {
-      guard case ._4(let v)? = self._2Of else { preconditionFailure() }
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 4)
-    }()
-    case ._5Field?: try {
-      guard case ._5Field(let v)? = self._2Of else { preconditionFailure() }
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 5)
-    }()
-    case nil: break
-    }
-    try { if let v = self._enumField {
-      try visitor.visitSingularEnumField(value: v, fieldNumber: 6)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0._1Field }, fieldNumber: 1, isUnset: { $0.__1Field == nil }),
+    .singularInt32({ $0.field }, fieldNumber: 2, isUnset: { $0._field == nil }),
+    .singularInt32({ $0._3Field3 }, fieldNumber: 3, isUnset: { $0.__3Field3 == nil }),
+    .oneOf({ $0._2Of }) {
+      switch $0 {
+      case ._4:
+        return _oneOfField__4
+      case ._5Field:
+        return _oneOfField__5Field
+      }
+    },
+    .singularEnum({ $0.enumField }, fieldNumber: 6, isUnset: { $0._enumField == nil }),
+  ]
+  private static let _oneOfField__4: Field<Self> = .singularInt32({ $0._4 }, fieldNumber: 4, isUnset: { _ in false })
+  private static let _oneOfField__5Field: Field<Self> = .singularInt32({ $0._5Field }, fieldNumber: 5, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Names_ValidIdentifiers, rhs: SwiftProtoTesting_Names_ValidIdentifiers) -> Bool {
     if lhs.__1Field != rhs.__1Field {return false}
@@ -26997,16 +25138,16 @@ extension SwiftProtoTesting_Names_SpecialNames1: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if case .str(let v)? = self.newValue {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .oneOf({ $0.newValue }) {
+      switch $0 {
+      case .str:
+        return _oneOfField_str
+      }
+    },
+  ]
+  private static let _oneOfField_str: Field<Self> = .singularString({ $0.str }, fieldNumber: 1, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Names_SpecialNames1, rhs: SwiftProtoTesting_Names_SpecialNames1) -> Bool {
     if lhs.newValue != rhs.newValue {return false}
@@ -27033,16 +25174,10 @@ extension SwiftProtoTesting_Names_SpecialNames2: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._newValue {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularString({ $0.newValue }, fieldNumber: 1, isUnset: { $0._newValue == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_SpecialNames2, rhs: SwiftProtoTesting_Names_SpecialNames2) -> Bool {
     if lhs._newValue != rhs._newValue {return false}
@@ -27102,21 +25237,17 @@ extension SwiftProtoTesting_Names_SpecialNames3: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if case .str(let v)? = _storage._newValue {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._forcesStorage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .oneOf({ $0.newValue }) {
+      switch $0 {
+      case .str:
+        return _oneOfField_str
+      }
+    },
+    .singularMessage({ $0.forcesStorage }, fieldNumber: 2, isUnset: { $0._storage._forcesStorage == nil }),
+  ]
+  private static let _oneOfField_str: Field<Self> = .singularString({ $0.str }, fieldNumber: 1, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Names_SpecialNames3, rhs: SwiftProtoTesting_Names_SpecialNames3) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -27178,21 +25309,11 @@ extension SwiftProtoTesting_Names_SpecialNames4: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._newValue {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._forcesStorage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularString({ $0.newValue }, fieldNumber: 1, isUnset: { $0._storage._newValue == nil }),
+    .singularMessage({ $0.forcesStorage }, fieldNumber: 2, isUnset: { $0._storage._forcesStorage == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Names_SpecialNames4, rhs: SwiftProtoTesting_Names_SpecialNames4) -> Bool {
     if lhs._storage !== rhs._storage {
diff --git a/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift
index 3225399ac..e7c5c4da9 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift
@@ -1156,10 +1156,10 @@ extension BaseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 1001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1, end: 1001),
+  ]
+
 
   static func ==(lhs: BaseMessage, rhs: BaseMessage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift
index 30cffa5d0..c64ba3772 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift
@@ -79,16 +79,10 @@ extension _4fun_SwiftProtoTesting_Mumble_MyMessage: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: _4fun_SwiftProtoTesting_Mumble_MyMessage, rhs: _4fun_SwiftProtoTesting_Mumble_MyMessage) -> Bool {
     if lhs._a != rhs._a {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift
index e0359e8c1..c3c39bb38 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift
@@ -223,16 +223,10 @@ extension SwiftProtoTesting_OneOfOptionMessage1: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._requiredField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.requiredField }, fieldNumber: 1, isUnset: { $0._requiredField == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_OneOfOptionMessage1, rhs: SwiftProtoTesting_OneOfOptionMessage1) -> Bool {
     if lhs._requiredField != rhs._requiredField {return false}
@@ -264,16 +258,10 @@ extension SwiftProtoTesting_OneOfOptionMessage2: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._requiredField {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.requiredField }, fieldNumber: 1, isUnset: { $0._requiredField == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_OneOfOptionMessage2, rhs: SwiftProtoTesting_OneOfOptionMessage2) -> Bool {
     if lhs._requiredField != rhs._requiredField {return false}
@@ -354,32 +342,25 @@ extension SwiftProtoTesting_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    switch self.option {
-    case .option1?: try {
-      guard case .option1(let v)? = self.option else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    }()
-    case .option2?: try {
-      guard case .option2(let v)? = self.option else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-    }()
-    case .option3?: try {
-      guard case .option3(let v)? = self.option else { preconditionFailure() }
-      try visitor.visitSingularGroupField(value: v, fieldNumber: 3)
-    }()
-    case .option4?: try {
-      guard case .option4(let v)? = self.option else { preconditionFailure() }
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 6)
-    }()
-    case nil: break
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .oneOf({ $0.option }) {
+      switch $0 {
+      case .option1:
+        return _oneOfField_option1
+      case .option2:
+        return _oneOfField_option2
+      case .option3:
+        return _oneOfField_option3
+      case .option4:
+        return _oneOfField_option4
+      }
+    },
+  ]
+  private static let _oneOfField_option1: Field<Self> = .singularMessage({ $0.option1 }, fieldNumber: 1, isUnset: { _ in false })
+  private static let _oneOfField_option2: Field<Self> = .singularMessage({ $0.option2 }, fieldNumber: 2, isUnset: { _ in false })
+  private static let _oneOfField_option3: Field<Self> = .singularGroup({ $0.option3 }, fieldNumber: 3, isUnset: { _ in false })
+  private static let _oneOfField_option4: Field<Self> = .singularInt32({ $0.option4 }, fieldNumber: 6, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_OneOfContainer, rhs: SwiftProtoTesting_OneOfContainer) -> Bool {
     if lhs.option != rhs.option {return false}
@@ -413,19 +394,11 @@ extension SwiftProtoTesting_OneOfContainer.Option3: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 4)
-    } }()
-    try { if let v = self._b {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 5)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 4, isUnset: { $0._a == nil }),
+    .singularString({ $0.b }, fieldNumber: 5, isUnset: { $0._b == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_OneOfContainer.Option3, rhs: SwiftProtoTesting_OneOfContainer.Option3) -> Bool {
     if lhs._a != rhs._a {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift
index 77599c68e..6ce4085b7 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift
@@ -229,32 +229,25 @@ extension SwiftProtoTesting_Merging_TestMessage: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    switch self.oneofField {
-    case .oneofUint32?: try {
-      guard case .oneofUint32(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111)
-    }()
-    case .oneofNestedMessage?: try {
-      guard case .oneofNestedMessage(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 112)
-    }()
-    case .oneofString?: try {
-      guard case .oneofString(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularStringField(value: v, fieldNumber: 113)
-    }()
-    case .oneofBytes?: try {
-      guard case .oneofBytes(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularBytesField(value: v, fieldNumber: 114)
-    }()
-    case nil: break
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .oneOf({ $0.oneofField }) {
+      switch $0 {
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofNestedMessage:
+        return _oneOfField_oneofNestedMessage
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
+      }
+    },
+  ]
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Merging_TestMessage, rhs: SwiftProtoTesting_Merging_TestMessage) -> Bool {
     if lhs.oneofField != rhs.oneofField {return false}
@@ -285,22 +278,12 @@ extension SwiftProtoTesting_Merging_TestMessage.NestedMessage: SwiftProtobuf.Mes
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._b {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._c {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._a == nil }),
+    .singularInt32({ $0.b }, fieldNumber: 2, isUnset: { $0._b == nil }),
+    .singularInt32({ $0.c }, fieldNumber: 3, isUnset: { $0._c == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Merging_TestMessage.NestedMessage, rhs: SwiftProtoTesting_Merging_TestMessage.NestedMessage) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -331,19 +314,11 @@ extension SwiftProtoTesting_Merging_TestParsingMerge: SwiftProtobuf.Message, Swi
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._optionalMessage {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    } }()
-    if !self.repeatedMessage.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.optionalMessage }, fieldNumber: 1, isUnset: { $0._optionalMessage == nil }),
+    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 2),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Merging_TestParsingMerge, rhs: SwiftProtoTesting_Merging_TestParsingMerge) -> Bool {
     if lhs._optionalMessage != rhs._optionalMessage {return false}
@@ -373,15 +348,11 @@ extension SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator: Sw
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if !self.field1.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1)
-    }
-    if !self.field2.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.field1 }, fieldNumber: 1),
+    .repeatedMessage({ $0.field2 }, fieldNumber: 2),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator, rhs: SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator) -> Bool {
     if lhs.field1 != rhs.field1 {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift
index c8a3e1143..801004f03 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift
@@ -574,37 +574,17 @@ extension SwiftProtoTesting_SwiftReservedTest: SwiftProtobuf.Message, SwiftProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._protoMessageName {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 10)
-    } }()
-    try { if let v = self._protoPackageName {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 11)
-    } }()
-    try { if let v = self._anyTypePrefix {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 12)
-    } }()
-    try { if let v = self._anyTypeURL {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 13)
-    } }()
-    try { if let v = self._isInitialized_p {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 20)
-    } }()
-    try { if let v = self._hashValue_p {
-      try visitor.visitSingularStringField(value: v, fieldNumber: 21)
-    } }()
-    try { if let v = self._debugDescription_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 22)
-    } }()
-    try { if let v = self._requiredInt {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 30)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.protoMessageName }, fieldNumber: 10, isUnset: { $0._protoMessageName == nil }),
+    .singularInt32({ $0.protoPackageName }, fieldNumber: 11, isUnset: { $0._protoPackageName == nil }),
+    .singularInt32({ $0.anyTypePrefix }, fieldNumber: 12, isUnset: { $0._anyTypePrefix == nil }),
+    .singularInt32({ $0.anyTypeURL }, fieldNumber: 13, isUnset: { $0._anyTypeURL == nil }),
+    .singularString({ $0.isInitialized_p }, fieldNumber: 20, isUnset: { $0._isInitialized_p == nil }),
+    .singularString({ $0.hashValue_p }, fieldNumber: 21, isUnset: { $0._hashValue_p == nil }),
+    .singularInt32({ $0.debugDescription_p }, fieldNumber: 22, isUnset: { $0._debugDescription_p == nil }),
+    .singularInt32({ $0.requiredInt }, fieldNumber: 30, isUnset: { $0._requiredInt == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_SwiftReservedTest, rhs: SwiftProtoTesting_SwiftReservedTest) -> Bool {
     if lhs._protoMessageName != rhs._protoMessageName {return false}
@@ -654,10 +634,10 @@ extension SwiftProtoTesting_SwiftReservedTest.classMessage: SwiftProtobuf.Messag
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 2001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 2001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_SwiftReservedTest.classMessage, rhs: SwiftProtoTesting_SwiftReservedTest.classMessage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -683,10 +663,10 @@ extension SwiftProtoTesting_SwiftReservedTest.TypeMessage: SwiftProtobuf.Message
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 2001)
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 2001),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_SwiftReservedTest.TypeMessage, rhs: SwiftProtoTesting_SwiftReservedTest.TypeMessage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -704,9 +684,9 @@ extension SwiftProtoTesting_SwiftReservedTest.isEqual: SwiftProtobuf.Message, Sw
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_SwiftReservedTest.isEqual, rhs: SwiftProtoTesting_SwiftReservedTest.isEqual) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -723,9 +703,9 @@ extension SwiftProtoTesting_SwiftReservedTestExt: SwiftProtobuf.Message, SwiftPr
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_SwiftReservedTestExt, rhs: SwiftProtoTesting_SwiftReservedTestExt) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift
index eac89c620..2a9864fa4 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift
@@ -349,9 +349,9 @@ extension SwiftReservedTestExt2: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftReservedTestExt2, rhs: SwiftReservedTestExt2) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift
index f6a7786ae..92b915daa 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift
@@ -1236,255 +1236,122 @@ extension SwiftProtoTesting_Message2: SwiftProtobuf.Message, SwiftProtobuf._Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._optionalInt32 {
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._optionalInt64 {
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._optionalUint32 {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._optionalUint64 {
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._optionalSint32 {
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._optionalSint64 {
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._optionalFixed32 {
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._optionalFixed64 {
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._optionalSfixed32 {
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._optionalSfixed64 {
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._optionalFloat {
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._optionalDouble {
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._optionalBool {
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._optionalString {
-        try visitor.visitSingularStringField(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._optionalBytes {
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._optionalGroup {
-        try visitor.visitSingularGroupField(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._optionalMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._optionalEnum {
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 19)
-      } }()
-      if !_storage._repeatedInt32.isEmpty {
-        try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31)
-      }
-      if !_storage._repeatedInt64.isEmpty {
-        try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32)
-      }
-      if !_storage._repeatedUint32.isEmpty {
-        try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33)
-      }
-      if !_storage._repeatedUint64.isEmpty {
-        try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34)
-      }
-      if !_storage._repeatedSint32.isEmpty {
-        try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35)
-      }
-      if !_storage._repeatedSint64.isEmpty {
-        try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36)
-      }
-      if !_storage._repeatedFixed32.isEmpty {
-        try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37)
-      }
-      if !_storage._repeatedFixed64.isEmpty {
-        try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38)
-      }
-      if !_storage._repeatedSfixed32.isEmpty {
-        try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39)
-      }
-      if !_storage._repeatedSfixed64.isEmpty {
-        try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40)
-      }
-      if !_storage._repeatedFloat.isEmpty {
-        try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41)
-      }
-      if !_storage._repeatedDouble.isEmpty {
-        try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42)
-      }
-      if !_storage._repeatedBool.isEmpty {
-        try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43)
-      }
-      if !_storage._repeatedString.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44)
-      }
-      if !_storage._repeatedBytes.isEmpty {
-        try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45)
-      }
-      if !_storage._repeatedGroup.isEmpty {
-        try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46)
-      }
-      if !_storage._repeatedMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedMessage, fieldNumber: 48)
-      }
-      if !_storage._repeatedEnum.isEmpty {
-        try visitor.visitRepeatedEnumField(value: _storage._repeatedEnum, fieldNumber: 49)
-      }
-      switch _storage._o {
-      case .oneofInt32?: try {
-        guard case .oneofInt32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 51)
-      }()
-      case .oneofInt64?: try {
-        guard case .oneofInt64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 52)
-      }()
-      case .oneofUint32?: try {
-        guard case .oneofUint32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 53)
-      }()
-      case .oneofUint64?: try {
-        guard case .oneofUint64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 54)
-      }()
-      case .oneofSint32?: try {
-        guard case .oneofSint32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 55)
-      }()
-      case .oneofSint64?: try {
-        guard case .oneofSint64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 56)
-      }()
-      case .oneofFixed32?: try {
-        guard case .oneofFixed32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 57)
-      }()
-      case .oneofFixed64?: try {
-        guard case .oneofFixed64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 58)
-      }()
-      case .oneofSfixed32?: try {
-        guard case .oneofSfixed32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 59)
-      }()
-      case .oneofSfixed64?: try {
-        guard case .oneofSfixed64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 60)
-      }()
-      case .oneofFloat?: try {
-        guard case .oneofFloat(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 61)
-      }()
-      case .oneofDouble?: try {
-        guard case .oneofDouble(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 62)
-      }()
-      case .oneofBool?: try {
-        guard case .oneofBool(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 63)
-      }()
-      case .oneofString?: try {
-        guard case .oneofString(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularStringField(value: v, fieldNumber: 64)
-      }()
-      case .oneofBytes?: try {
-        guard case .oneofBytes(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 65)
-      }()
-      case .oneofGroup?: try {
-        guard case .oneofGroup(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularGroupField(value: v, fieldNumber: 66)
-      }()
-      case .oneofMessage?: try {
-        guard case .oneofMessage(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 68)
-      }()
-      case .oneofEnum?: try {
-        guard case .oneofEnum(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 69)
-      }()
-      case nil: break
-      }
-      if !_storage._mapInt32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapInt32Int32, fieldNumber: 70)
-      }
-      if !_storage._mapInt64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapInt64Int64, fieldNumber: 71)
-      }
-      if !_storage._mapUint32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapUint32Uint32, fieldNumber: 72)
-      }
-      if !_storage._mapUint64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapUint64Uint64, fieldNumber: 73)
-      }
-      if !_storage._mapSint32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSint32Sint32, fieldNumber: 74)
-      }
-      if !_storage._mapSint64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSint64Sint64, fieldNumber: 75)
-      }
-      if !_storage._mapFixed32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapFixed32Fixed32, fieldNumber: 76)
-      }
-      if !_storage._mapFixed64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapFixed64Fixed64, fieldNumber: 77)
-      }
-      if !_storage._mapSfixed32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 78)
-      }
-      if !_storage._mapSfixed64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 79)
-      }
-      if !_storage._mapInt32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapInt32Float, fieldNumber: 80)
-      }
-      if !_storage._mapInt32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapInt32Double, fieldNumber: 81)
-      }
-      if !_storage._mapBoolBool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapBoolBool, fieldNumber: 82)
-      }
-      if !_storage._mapStringString.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, value: _storage._mapStringString, fieldNumber: 83)
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalInt32 }, fieldNumber: 1, isUnset: { $0._storage._optionalInt32 == nil }),
+    .singularInt64({ $0.optionalInt64 }, fieldNumber: 2, isUnset: { $0._storage._optionalInt64 == nil }),
+    .singularUInt32({ $0.optionalUint32 }, fieldNumber: 3, isUnset: { $0._storage._optionalUint32 == nil }),
+    .singularUInt64({ $0.optionalUint64 }, fieldNumber: 4, isUnset: { $0._storage._optionalUint64 == nil }),
+    .singularSInt32({ $0.optionalSint32 }, fieldNumber: 5, isUnset: { $0._storage._optionalSint32 == nil }),
+    .singularSInt64({ $0.optionalSint64 }, fieldNumber: 6, isUnset: { $0._storage._optionalSint64 == nil }),
+    .singularFixed32({ $0.optionalFixed32 }, fieldNumber: 7, isUnset: { $0._storage._optionalFixed32 == nil }),
+    .singularFixed64({ $0.optionalFixed64 }, fieldNumber: 8, isUnset: { $0._storage._optionalFixed64 == nil }),
+    .singularSFixed32({ $0.optionalSfixed32 }, fieldNumber: 9, isUnset: { $0._storage._optionalSfixed32 == nil }),
+    .singularSFixed64({ $0.optionalSfixed64 }, fieldNumber: 10, isUnset: { $0._storage._optionalSfixed64 == nil }),
+    .singularFloat({ $0.optionalFloat }, fieldNumber: 11, isUnset: { $0._storage._optionalFloat == nil }),
+    .singularDouble({ $0.optionalDouble }, fieldNumber: 12, isUnset: { $0._storage._optionalDouble == nil }),
+    .singularBool({ $0.optionalBool }, fieldNumber: 13, isUnset: { $0._storage._optionalBool == nil }),
+    .singularString({ $0.optionalString }, fieldNumber: 14, isUnset: { $0._storage._optionalString == nil }),
+    .singularBytes({ $0.optionalBytes }, fieldNumber: 15, isUnset: { $0._storage._optionalBytes == nil }),
+    .singularGroup({ $0.optionalGroup }, fieldNumber: 16, isUnset: { $0._storage._optionalGroup == nil }),
+    .singularMessage({ $0.optionalMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalMessage == nil }),
+    .singularEnum({ $0.optionalEnum }, fieldNumber: 19, isUnset: { $0._storage._optionalEnum == nil }),
+    .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
+    .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
+    .repeatedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
+    .repeatedUInt64({ $0.repeatedUint64 }, fieldNumber: 34),
+    .repeatedSInt32({ $0.repeatedSint32 }, fieldNumber: 35),
+    .repeatedSInt64({ $0.repeatedSint64 }, fieldNumber: 36),
+    .repeatedFixed32({ $0.repeatedFixed32 }, fieldNumber: 37),
+    .repeatedFixed64({ $0.repeatedFixed64 }, fieldNumber: 38),
+    .repeatedSFixed32({ $0.repeatedSfixed32 }, fieldNumber: 39),
+    .repeatedSFixed64({ $0.repeatedSfixed64 }, fieldNumber: 40),
+    .repeatedFloat({ $0.repeatedFloat }, fieldNumber: 41),
+    .repeatedDouble({ $0.repeatedDouble }, fieldNumber: 42),
+    .repeatedBool({ $0.repeatedBool }, fieldNumber: 43),
+    .repeatedString({ $0.repeatedString }, fieldNumber: 44),
+    .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
+    .repeatedGroup({ $0.repeatedGroup }, fieldNumber: 46),
+    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 48),
+    .repeatedEnum({ $0.repeatedEnum }, fieldNumber: 49),
+    .oneOf({ $0.o }) {
+      switch $0 {
+      case .oneofInt32:
+        return _oneOfField_oneofInt32
+      case .oneofInt64:
+        return _oneOfField_oneofInt64
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofUint64:
+        return _oneOfField_oneofUint64
+      case .oneofSint32:
+        return _oneOfField_oneofSint32
+      case .oneofSint64:
+        return _oneOfField_oneofSint64
+      case .oneofFixed32:
+        return _oneOfField_oneofFixed32
+      case .oneofFixed64:
+        return _oneOfField_oneofFixed64
+      case .oneofSfixed32:
+        return _oneOfField_oneofSfixed32
+      case .oneofSfixed64:
+        return _oneOfField_oneofSfixed64
+      case .oneofFloat:
+        return _oneOfField_oneofFloat
+      case .oneofDouble:
+        return _oneOfField_oneofDouble
+      case .oneofBool:
+        return _oneOfField_oneofBool
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
+      case .oneofGroup:
+        return _oneOfField_oneofGroup
+      case .oneofMessage:
+        return _oneOfField_oneofMessage
+      case .oneofEnum:
+        return _oneOfField_oneofEnum
       }
-      if !_storage._mapStringBytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapStringBytes, fieldNumber: 84)
-      }
-      if !_storage._mapStringMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Message2>.self, value: _storage._mapStringMessage, fieldNumber: 85)
-      }
-      if !_storage._mapInt32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapInt32Bytes, fieldNumber: 86)
-      }
-      if !_storage._mapInt32Enum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message2.Enum>.self, value: _storage._mapInt32Enum, fieldNumber: 87)
-      }
-      if !_storage._mapInt32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message2>.self, value: _storage._mapInt32Message, fieldNumber: 88)
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+    },
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 70),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 71),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 72),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 73),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 74),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 75),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 76),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 77),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 78),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 79),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 80),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 81),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 82),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 83),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0.mapStringBytes }, fieldNumber: 84),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Message2>.self, { $0.mapStringMessage }, fieldNumber: 85),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt32Bytes }, fieldNumber: 86),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message2.Enum>.self, { $0.mapInt32Enum }, fieldNumber: 87),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message2>.self, { $0.mapInt32Message }, fieldNumber: 88),
+  ]
+  private static let _oneOfField_oneofInt32: Field<Self> = .singularInt32({ $0.oneofInt32 }, fieldNumber: 51, isUnset: { _ in false })
+  private static let _oneOfField_oneofInt64: Field<Self> = .singularInt64({ $0.oneofInt64 }, fieldNumber: 52, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 53, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint64: Field<Self> = .singularUInt64({ $0.oneofUint64 }, fieldNumber: 54, isUnset: { _ in false })
+  private static let _oneOfField_oneofSint32: Field<Self> = .singularSInt32({ $0.oneofSint32 }, fieldNumber: 55, isUnset: { _ in false })
+  private static let _oneOfField_oneofSint64: Field<Self> = .singularSInt64({ $0.oneofSint64 }, fieldNumber: 56, isUnset: { _ in false })
+  private static let _oneOfField_oneofFixed32: Field<Self> = .singularFixed32({ $0.oneofFixed32 }, fieldNumber: 57, isUnset: { _ in false })
+  private static let _oneOfField_oneofFixed64: Field<Self> = .singularFixed64({ $0.oneofFixed64 }, fieldNumber: 58, isUnset: { _ in false })
+  private static let _oneOfField_oneofSfixed32: Field<Self> = .singularSFixed32({ $0.oneofSfixed32 }, fieldNumber: 59, isUnset: { _ in false })
+  private static let _oneOfField_oneofSfixed64: Field<Self> = .singularSFixed64({ $0.oneofSfixed64 }, fieldNumber: 60, isUnset: { _ in false })
+  private static let _oneOfField_oneofFloat: Field<Self> = .singularFloat({ $0.oneofFloat }, fieldNumber: 61, isUnset: { _ in false })
+  private static let _oneOfField_oneofDouble: Field<Self> = .singularDouble({ $0.oneofDouble }, fieldNumber: 62, isUnset: { _ in false })
+  private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 63, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 64, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 65, isUnset: { _ in false })
+  private static let _oneOfField_oneofGroup: Field<Self> = .singularGroup({ $0.oneofGroup }, fieldNumber: 66, isUnset: { _ in false })
+  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 68, isUnset: { _ in false })
+  private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 69, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Message2, rhs: SwiftProtoTesting_Message2) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -1583,16 +1450,10 @@ extension SwiftProtoTesting_Message2.OptionalGroup: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 17)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 17, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Message2.OptionalGroup, rhs: SwiftProtoTesting_Message2.OptionalGroup) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -1619,16 +1480,10 @@ extension SwiftProtoTesting_Message2.RepeatedGroup: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 47)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 47, isUnset: { $0._a == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Message2.RepeatedGroup, rhs: SwiftProtoTesting_Message2.RepeatedGroup) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -1657,19 +1512,11 @@ extension SwiftProtoTesting_Message2.OneofGroup: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._a {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 67)
-    } }()
-    try { if let v = self._b {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 167)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.a }, fieldNumber: 67, isUnset: { $0._a == nil }),
+    .singularInt32({ $0.b }, fieldNumber: 167, isUnset: { $0._b == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Message2.OneofGroup, rhs: SwiftProtoTesting_Message2.OneofGroup) -> Bool {
     if lhs._a != rhs._a {return false}
@@ -1688,9 +1535,9 @@ extension SwiftProtoTesting_Msg2NoStorage: SwiftProtobuf.Message, SwiftProtobuf.
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Msg2NoStorage, rhs: SwiftProtoTesting_Msg2NoStorage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -1738,18 +1585,10 @@ extension SwiftProtoTesting_Msg2UsesStorage: SwiftProtobuf.Message, SwiftProtobu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._y {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 999)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.y }, fieldNumber: 999, isUnset: { $0._storage._y == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Msg2UsesStorage, rhs: SwiftProtoTesting_Msg2UsesStorage) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -1788,22 +1627,12 @@ extension SwiftProtoTesting_Msg2NamesNoStorage: SwiftProtobuf.Message, SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._isInitialized_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._debugDescription_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._value {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isInitialized_p }, fieldNumber: 1, isUnset: { $0._isInitialized_p == nil }),
+    .singularInt32({ $0.debugDescription_p }, fieldNumber: 2, isUnset: { $0._debugDescription_p == nil }),
+    .singularInt32({ $0.value }, fieldNumber: 3, isUnset: { $0._value == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Msg2NamesNoStorage, rhs: SwiftProtoTesting_Msg2NamesNoStorage) -> Bool {
     if lhs._isInitialized_p != rhs._isInitialized_p {return false}
@@ -1836,22 +1665,12 @@ extension SwiftProtoTesting_Msg2NamesUsesStorage: SwiftProtobuf.Message, SwiftPr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._isInitialized_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
-    } }()
-    try { if let v = self._debugDescription_p {
-      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
-    } }()
-    try { if let v = self._value {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isInitialized_p }, fieldNumber: 1, isUnset: { $0._isInitialized_p == nil }),
+    .singularInt32({ $0.debugDescription_p }, fieldNumber: 2, isUnset: { $0._debugDescription_p == nil }),
+    .singularMessage({ $0.value }, fieldNumber: 3, isUnset: { $0._value == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Msg2NamesUsesStorage, rhs: SwiftProtoTesting_Msg2NamesUsesStorage) -> Bool {
     if lhs._isInitialized_p != rhs._isInitialized_p {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift
index 55e622b16..da7015d6a 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift
@@ -1027,245 +1027,117 @@ extension SwiftProtoTesting_Message3: SwiftProtobuf.Message, SwiftProtobuf._Mess
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      if _storage._optionalInt32 != 0 {
-        try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1)
-      }
-      if _storage._optionalInt64 != 0 {
-        try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2)
-      }
-      if _storage._optionalUint32 != 0 {
-        try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3)
-      }
-      if _storage._optionalUint64 != 0 {
-        try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4)
-      }
-      if _storage._optionalSint32 != 0 {
-        try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5)
-      }
-      if _storage._optionalSint64 != 0 {
-        try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6)
-      }
-      if _storage._optionalFixed32 != 0 {
-        try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7)
-      }
-      if _storage._optionalFixed64 != 0 {
-        try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8)
-      }
-      if _storage._optionalSfixed32 != 0 {
-        try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9)
-      }
-      if _storage._optionalSfixed64 != 0 {
-        try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10)
-      }
-      if _storage._optionalFloat != 0 {
-        try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11)
-      }
-      if _storage._optionalDouble != 0 {
-        try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12)
-      }
-      if _storage._optionalBool != false {
-        try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13)
-      }
-      if !_storage._optionalString.isEmpty {
-        try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14)
-      }
-      if !_storage._optionalBytes.isEmpty {
-        try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15)
-      }
-      try { if let v = _storage._optionalMessage {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      if _storage._optionalEnum != .foo {
-        try visitor.visitSingularEnumField(value: _storage._optionalEnum, fieldNumber: 19)
-      }
-      if !_storage._repeatedInt32.isEmpty {
-        try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31)
-      }
-      if !_storage._repeatedInt64.isEmpty {
-        try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32)
-      }
-      if !_storage._repeatedUint32.isEmpty {
-        try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33)
-      }
-      if !_storage._repeatedUint64.isEmpty {
-        try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34)
-      }
-      if !_storage._repeatedSint32.isEmpty {
-        try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35)
-      }
-      if !_storage._repeatedSint64.isEmpty {
-        try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36)
-      }
-      if !_storage._repeatedFixed32.isEmpty {
-        try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37)
-      }
-      if !_storage._repeatedFixed64.isEmpty {
-        try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38)
-      }
-      if !_storage._repeatedSfixed32.isEmpty {
-        try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39)
-      }
-      if !_storage._repeatedSfixed64.isEmpty {
-        try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40)
-      }
-      if !_storage._repeatedFloat.isEmpty {
-        try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41)
-      }
-      if !_storage._repeatedDouble.isEmpty {
-        try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42)
-      }
-      if !_storage._repeatedBool.isEmpty {
-        try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43)
-      }
-      if !_storage._repeatedString.isEmpty {
-        try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44)
-      }
-      if !_storage._repeatedBytes.isEmpty {
-        try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45)
-      }
-      if !_storage._repeatedMessage.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._repeatedMessage, fieldNumber: 48)
-      }
-      if !_storage._repeatedEnum.isEmpty {
-        try visitor.visitPackedEnumField(value: _storage._repeatedEnum, fieldNumber: 49)
-      }
-      switch _storage._o {
-      case .oneofInt32?: try {
-        guard case .oneofInt32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularInt32Field(value: v, fieldNumber: 51)
-      }()
-      case .oneofInt64?: try {
-        guard case .oneofInt64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularInt64Field(value: v, fieldNumber: 52)
-      }()
-      case .oneofUint32?: try {
-        guard case .oneofUint32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 53)
-      }()
-      case .oneofUint64?: try {
-        guard case .oneofUint64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 54)
-      }()
-      case .oneofSint32?: try {
-        guard case .oneofSint32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSInt32Field(value: v, fieldNumber: 55)
-      }()
-      case .oneofSint64?: try {
-        guard case .oneofSint64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSInt64Field(value: v, fieldNumber: 56)
-      }()
-      case .oneofFixed32?: try {
-        guard case .oneofFixed32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFixed32Field(value: v, fieldNumber: 57)
-      }()
-      case .oneofFixed64?: try {
-        guard case .oneofFixed64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFixed64Field(value: v, fieldNumber: 58)
-      }()
-      case .oneofSfixed32?: try {
-        guard case .oneofSfixed32(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 59)
-      }()
-      case .oneofSfixed64?: try {
-        guard case .oneofSfixed64(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 60)
-      }()
-      case .oneofFloat?: try {
-        guard case .oneofFloat(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularFloatField(value: v, fieldNumber: 61)
-      }()
-      case .oneofDouble?: try {
-        guard case .oneofDouble(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularDoubleField(value: v, fieldNumber: 62)
-      }()
-      case .oneofBool?: try {
-        guard case .oneofBool(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularBoolField(value: v, fieldNumber: 63)
-      }()
-      case .oneofString?: try {
-        guard case .oneofString(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularStringField(value: v, fieldNumber: 64)
-      }()
-      case .oneofBytes?: try {
-        guard case .oneofBytes(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularBytesField(value: v, fieldNumber: 65)
-      }()
-      case .oneofMessage?: try {
-        guard case .oneofMessage(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 68)
-      }()
-      case .oneofEnum?: try {
-        guard case .oneofEnum(let v)? = _storage._o else { preconditionFailure() }
-        try visitor.visitSingularEnumField(value: v, fieldNumber: 69)
-      }()
-      case nil: break
-      }
-      if !_storage._mapInt32Int32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, value: _storage._mapInt32Int32, fieldNumber: 70)
-      }
-      if !_storage._mapInt64Int64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, value: _storage._mapInt64Int64, fieldNumber: 71)
-      }
-      if !_storage._mapUint32Uint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, value: _storage._mapUint32Uint32, fieldNumber: 72)
-      }
-      if !_storage._mapUint64Uint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, value: _storage._mapUint64Uint64, fieldNumber: 73)
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.optionalInt32 }, fieldNumber: 1),
+    .singularInt64({ $0.optionalInt64 }, fieldNumber: 2),
+    .singularUInt32({ $0.optionalUint32 }, fieldNumber: 3),
+    .singularUInt64({ $0.optionalUint64 }, fieldNumber: 4),
+    .singularSInt32({ $0.optionalSint32 }, fieldNumber: 5),
+    .singularSInt64({ $0.optionalSint64 }, fieldNumber: 6),
+    .singularFixed32({ $0.optionalFixed32 }, fieldNumber: 7),
+    .singularFixed64({ $0.optionalFixed64 }, fieldNumber: 8),
+    .singularSFixed32({ $0.optionalSfixed32 }, fieldNumber: 9),
+    .singularSFixed64({ $0.optionalSfixed64 }, fieldNumber: 10),
+    .singularFloat({ $0.optionalFloat }, fieldNumber: 11),
+    .singularDouble({ $0.optionalDouble }, fieldNumber: 12),
+    .singularBool({ $0.optionalBool }, fieldNumber: 13),
+    .singularString({ $0.optionalString }, fieldNumber: 14),
+    .singularBytes({ $0.optionalBytes }, fieldNumber: 15),
+    .singularMessage({ $0.optionalMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalMessage == nil }),
+    .singularEnum({ $0.optionalEnum }, fieldNumber: 19, defaultValue: .foo),
+    .packedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
+    .packedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
+    .packedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
+    .packedUInt64({ $0.repeatedUint64 }, fieldNumber: 34),
+    .packedSInt32({ $0.repeatedSint32 }, fieldNumber: 35),
+    .packedSInt64({ $0.repeatedSint64 }, fieldNumber: 36),
+    .packedFixed32({ $0.repeatedFixed32 }, fieldNumber: 37),
+    .packedFixed64({ $0.repeatedFixed64 }, fieldNumber: 38),
+    .packedSFixed32({ $0.repeatedSfixed32 }, fieldNumber: 39),
+    .packedSFixed64({ $0.repeatedSfixed64 }, fieldNumber: 40),
+    .packedFloat({ $0.repeatedFloat }, fieldNumber: 41),
+    .packedDouble({ $0.repeatedDouble }, fieldNumber: 42),
+    .packedBool({ $0.repeatedBool }, fieldNumber: 43),
+    .repeatedString({ $0.repeatedString }, fieldNumber: 44),
+    .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
+    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 48),
+    .packedEnum({ $0.repeatedEnum }, fieldNumber: 49),
+    .oneOf({ $0.o }) {
+      switch $0 {
+      case .oneofInt32:
+        return _oneOfField_oneofInt32
+      case .oneofInt64:
+        return _oneOfField_oneofInt64
+      case .oneofUint32:
+        return _oneOfField_oneofUint32
+      case .oneofUint64:
+        return _oneOfField_oneofUint64
+      case .oneofSint32:
+        return _oneOfField_oneofSint32
+      case .oneofSint64:
+        return _oneOfField_oneofSint64
+      case .oneofFixed32:
+        return _oneOfField_oneofFixed32
+      case .oneofFixed64:
+        return _oneOfField_oneofFixed64
+      case .oneofSfixed32:
+        return _oneOfField_oneofSfixed32
+      case .oneofSfixed64:
+        return _oneOfField_oneofSfixed64
+      case .oneofFloat:
+        return _oneOfField_oneofFloat
+      case .oneofDouble:
+        return _oneOfField_oneofDouble
+      case .oneofBool:
+        return _oneOfField_oneofBool
+      case .oneofString:
+        return _oneOfField_oneofString
+      case .oneofBytes:
+        return _oneOfField_oneofBytes
+      case .oneofMessage:
+        return _oneOfField_oneofMessage
+      case .oneofEnum:
+        return _oneOfField_oneofEnum
       }
-      if !_storage._mapSint32Sint32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, value: _storage._mapSint32Sint32, fieldNumber: 74)
-      }
-      if !_storage._mapSint64Sint64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, value: _storage._mapSint64Sint64, fieldNumber: 75)
-      }
-      if !_storage._mapFixed32Fixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, value: _storage._mapFixed32Fixed32, fieldNumber: 76)
-      }
-      if !_storage._mapFixed64Fixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, value: _storage._mapFixed64Fixed64, fieldNumber: 77)
-      }
-      if !_storage._mapSfixed32Sfixed32.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 78)
-      }
-      if !_storage._mapSfixed64Sfixed64.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 79)
-      }
-      if !_storage._mapInt32Float.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, value: _storage._mapInt32Float, fieldNumber: 80)
-      }
-      if !_storage._mapInt32Double.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, value: _storage._mapInt32Double, fieldNumber: 81)
-      }
-      if !_storage._mapBoolBool.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, value: _storage._mapBoolBool, fieldNumber: 82)
-      }
-      if !_storage._mapStringString.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, value: _storage._mapStringString, fieldNumber: 83)
-      }
-      if !_storage._mapStringBytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapStringBytes, fieldNumber: 84)
-      }
-      if !_storage._mapStringMessage.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Message3>.self, value: _storage._mapStringMessage, fieldNumber: 85)
-      }
-      if !_storage._mapInt32Bytes.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, value: _storage._mapInt32Bytes, fieldNumber: 86)
-      }
-      if !_storage._mapInt32Enum.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message3.Enum>.self, value: _storage._mapInt32Enum, fieldNumber: 87)
-      }
-      if !_storage._mapInt32Message.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message3>.self, value: _storage._mapInt32Message, fieldNumber: 88)
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+    },
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 70),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 71),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 72),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 73),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 74),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 75),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 76),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 77),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 78),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 79),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 80),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 81),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 82),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 83),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0.mapStringBytes }, fieldNumber: 84),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Message3>.self, { $0.mapStringMessage }, fieldNumber: 85),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt32Bytes }, fieldNumber: 86),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message3.Enum>.self, { $0.mapInt32Enum }, fieldNumber: 87),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message3>.self, { $0.mapInt32Message }, fieldNumber: 88),
+  ]
+  private static let _oneOfField_oneofInt32: Field<Self> = .singularInt32({ $0.oneofInt32 }, fieldNumber: 51, isUnset: { _ in false })
+  private static let _oneOfField_oneofInt64: Field<Self> = .singularInt64({ $0.oneofInt64 }, fieldNumber: 52, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 53, isUnset: { _ in false })
+  private static let _oneOfField_oneofUint64: Field<Self> = .singularUInt64({ $0.oneofUint64 }, fieldNumber: 54, isUnset: { _ in false })
+  private static let _oneOfField_oneofSint32: Field<Self> = .singularSInt32({ $0.oneofSint32 }, fieldNumber: 55, isUnset: { _ in false })
+  private static let _oneOfField_oneofSint64: Field<Self> = .singularSInt64({ $0.oneofSint64 }, fieldNumber: 56, isUnset: { _ in false })
+  private static let _oneOfField_oneofFixed32: Field<Self> = .singularFixed32({ $0.oneofFixed32 }, fieldNumber: 57, isUnset: { _ in false })
+  private static let _oneOfField_oneofFixed64: Field<Self> = .singularFixed64({ $0.oneofFixed64 }, fieldNumber: 58, isUnset: { _ in false })
+  private static let _oneOfField_oneofSfixed32: Field<Self> = .singularSFixed32({ $0.oneofSfixed32 }, fieldNumber: 59, isUnset: { _ in false })
+  private static let _oneOfField_oneofSfixed64: Field<Self> = .singularSFixed64({ $0.oneofSfixed64 }, fieldNumber: 60, isUnset: { _ in false })
+  private static let _oneOfField_oneofFloat: Field<Self> = .singularFloat({ $0.oneofFloat }, fieldNumber: 61, isUnset: { _ in false })
+  private static let _oneOfField_oneofDouble: Field<Self> = .singularDouble({ $0.oneofDouble }, fieldNumber: 62, isUnset: { _ in false })
+  private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 63, isUnset: { _ in false })
+  private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 64, isUnset: { _ in false })
+  private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 65, isUnset: { _ in false })
+  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 68, isUnset: { _ in false })
+  private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 69, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_Message3, rhs: SwiftProtoTesting_Message3) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -1353,9 +1225,9 @@ extension SwiftProtoTesting_Msg3NoStorage: SwiftProtobuf.Message, SwiftProtobuf.
     while try decoder.nextFieldNumber() != nil {}
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Msg3NoStorage, rhs: SwiftProtoTesting_Msg3NoStorage) -> Bool {
     if lhs.unknownFields != rhs.unknownFields {return false}
@@ -1403,18 +1275,10 @@ extension SwiftProtoTesting_Msg3UsesStorage: SwiftProtobuf.Message, SwiftProtobu
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._y {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 999)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.y }, fieldNumber: 999, isUnset: { $0._storage._y == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Msg3UsesStorage, rhs: SwiftProtoTesting_Msg3UsesStorage) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -1453,18 +1317,12 @@ extension SwiftProtoTesting_Msg3NamesNoStorage: SwiftProtobuf.Message, SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    if self.isInitialized_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.isInitialized_p, fieldNumber: 1)
-    }
-    if self.debugDescription_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.debugDescription_p, fieldNumber: 2)
-    }
-    if self.hasValue_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.hasValue_p, fieldNumber: 3)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isInitialized_p }, fieldNumber: 1),
+    .singularInt32({ $0.debugDescription_p }, fieldNumber: 2),
+    .singularInt32({ $0.hasValue_p }, fieldNumber: 3),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Msg3NamesNoStorage, rhs: SwiftProtoTesting_Msg3NamesNoStorage) -> Bool {
     if lhs.isInitialized_p != rhs.isInitialized_p {return false}
@@ -1497,22 +1355,12 @@ extension SwiftProtoTesting_Msg3NamesUsesStorage: SwiftProtobuf.Message, SwiftPr
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    if self.isInitialized_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.isInitialized_p, fieldNumber: 1)
-    }
-    if self.debugDescription_p != 0 {
-      try visitor.visitSingularInt32Field(value: self.debugDescription_p, fieldNumber: 2)
-    }
-    try { if let v = self._value {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    } }()
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularInt32({ $0.isInitialized_p }, fieldNumber: 1),
+    .singularInt32({ $0.debugDescription_p }, fieldNumber: 2),
+    .singularMessage({ $0.value }, fieldNumber: 3, isUnset: { $0._value == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_Msg3NamesUsesStorage, rhs: SwiftProtoTesting_Msg3NamesUsesStorage) -> Bool {
     if lhs.isInitialized_p != rhs.isInitialized_p {return false}
diff --git a/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift b/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift
index b4c4ca925..5d0837329 100644
--- a/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift
@@ -740,72 +740,28 @@ extension SwiftProtoTesting_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProt
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every if/case branch local when no optimizations
-      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-      // https://github.com/apple/swift-protobuf/issues/1182
-      try { if let v = _storage._anyField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-      } }()
-      try { if let v = _storage._apiField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-      } }()
-      try { if let v = _storage._durationField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-      } }()
-      try { if let v = _storage._emptyField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
-      } }()
-      try { if let v = _storage._fieldMaskField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
-      } }()
-      try { if let v = _storage._sourceContextField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 6)
-      } }()
-      try { if let v = _storage._structField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
-      } }()
-      try { if let v = _storage._timestampField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
-      } }()
-      try { if let v = _storage._typeField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._doubleField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._floatField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._int64Field {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._uint64Field {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 13)
-      } }()
-      try { if let v = _storage._int32Field {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 14)
-      } }()
-      try { if let v = _storage._uint32Field {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 15)
-      } }()
-      try { if let v = _storage._boolField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 16)
-      } }()
-      try { if let v = _storage._stringField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 17)
-      } }()
-      try { if let v = _storage._bytesField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-      } }()
-      try { if let v = _storage._valueField {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 19)
-      } }()
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .singularMessage({ $0.anyField }, fieldNumber: 1, isUnset: { $0._storage._anyField == nil }),
+    .singularMessage({ $0.apiField }, fieldNumber: 2, isUnset: { $0._storage._apiField == nil }),
+    .singularMessage({ $0.durationField }, fieldNumber: 3, isUnset: { $0._storage._durationField == nil }),
+    .singularMessage({ $0.emptyField }, fieldNumber: 4, isUnset: { $0._storage._emptyField == nil }),
+    .singularMessage({ $0.fieldMaskField }, fieldNumber: 5, isUnset: { $0._storage._fieldMaskField == nil }),
+    .singularMessage({ $0.sourceContextField }, fieldNumber: 6, isUnset: { $0._storage._sourceContextField == nil }),
+    .singularMessage({ $0.structField }, fieldNumber: 7, isUnset: { $0._storage._structField == nil }),
+    .singularMessage({ $0.timestampField }, fieldNumber: 8, isUnset: { $0._storage._timestampField == nil }),
+    .singularMessage({ $0.typeField }, fieldNumber: 9, isUnset: { $0._storage._typeField == nil }),
+    .singularMessage({ $0.doubleField }, fieldNumber: 10, isUnset: { $0._storage._doubleField == nil }),
+    .singularMessage({ $0.floatField }, fieldNumber: 11, isUnset: { $0._storage._floatField == nil }),
+    .singularMessage({ $0.int64Field }, fieldNumber: 12, isUnset: { $0._storage._int64Field == nil }),
+    .singularMessage({ $0.uint64Field }, fieldNumber: 13, isUnset: { $0._storage._uint64Field == nil }),
+    .singularMessage({ $0.int32Field }, fieldNumber: 14, isUnset: { $0._storage._int32Field == nil }),
+    .singularMessage({ $0.uint32Field }, fieldNumber: 15, isUnset: { $0._storage._uint32Field == nil }),
+    .singularMessage({ $0.boolField }, fieldNumber: 16, isUnset: { $0._storage._boolField == nil }),
+    .singularMessage({ $0.stringField }, fieldNumber: 17, isUnset: { $0._storage._stringField == nil }),
+    .singularMessage({ $0.bytesField }, fieldNumber: 18, isUnset: { $0._storage._bytesField == nil }),
+    .singularMessage({ $0.valueField }, fieldNumber: 19, isUnset: { $0._storage._valueField == nil }),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_TestWellKnownTypes, rhs: SwiftProtoTesting_TestWellKnownTypes) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -948,65 +904,27 @@ extension SwiftProtoTesting_RepeatedWellKnownTypes: SwiftProtobuf.Message, Swift
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      if !_storage._anyField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._anyField, fieldNumber: 1)
-      }
-      if !_storage._apiField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._apiField, fieldNumber: 2)
-      }
-      if !_storage._durationField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._durationField, fieldNumber: 3)
-      }
-      if !_storage._emptyField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._emptyField, fieldNumber: 4)
-      }
-      if !_storage._fieldMaskField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._fieldMaskField, fieldNumber: 5)
-      }
-      if !_storage._sourceContextField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._sourceContextField, fieldNumber: 6)
-      }
-      if !_storage._structField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._structField, fieldNumber: 7)
-      }
-      if !_storage._timestampField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._timestampField, fieldNumber: 8)
-      }
-      if !_storage._typeField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._typeField, fieldNumber: 9)
-      }
-      if !_storage._doubleField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._doubleField, fieldNumber: 10)
-      }
-      if !_storage._floatField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._floatField, fieldNumber: 11)
-      }
-      if !_storage._int64Field.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._int64Field, fieldNumber: 12)
-      }
-      if !_storage._uint64Field.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._uint64Field, fieldNumber: 13)
-      }
-      if !_storage._int32Field.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._int32Field, fieldNumber: 14)
-      }
-      if !_storage._uint32Field.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._uint32Field, fieldNumber: 15)
-      }
-      if !_storage._boolField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._boolField, fieldNumber: 16)
-      }
-      if !_storage._stringField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._stringField, fieldNumber: 17)
-      }
-      if !_storage._bytesField.isEmpty {
-        try visitor.visitRepeatedMessageField(value: _storage._bytesField, fieldNumber: 18)
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .repeatedMessage({ $0.anyField }, fieldNumber: 1),
+    .repeatedMessage({ $0.apiField }, fieldNumber: 2),
+    .repeatedMessage({ $0.durationField }, fieldNumber: 3),
+    .repeatedMessage({ $0.emptyField }, fieldNumber: 4),
+    .repeatedMessage({ $0.fieldMaskField }, fieldNumber: 5),
+    .repeatedMessage({ $0.sourceContextField }, fieldNumber: 6),
+    .repeatedMessage({ $0.structField }, fieldNumber: 7),
+    .repeatedMessage({ $0.timestampField }, fieldNumber: 8),
+    .repeatedMessage({ $0.typeField }, fieldNumber: 9),
+    .repeatedMessage({ $0.doubleField }, fieldNumber: 10),
+    .repeatedMessage({ $0.floatField }, fieldNumber: 11),
+    .repeatedMessage({ $0.int64Field }, fieldNumber: 12),
+    .repeatedMessage({ $0.uint64Field }, fieldNumber: 13),
+    .repeatedMessage({ $0.int32Field }, fieldNumber: 14),
+    .repeatedMessage({ $0.uint32Field }, fieldNumber: 15),
+    .repeatedMessage({ $0.boolField }, fieldNumber: 16),
+    .repeatedMessage({ $0.stringField }, fieldNumber: 17),
+    .repeatedMessage({ $0.bytesField }, fieldNumber: 18),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_RepeatedWellKnownTypes, rhs: SwiftProtoTesting_RepeatedWellKnownTypes) -> Bool {
     if lhs._storage !== rhs._storage {
@@ -1308,88 +1226,67 @@ extension SwiftProtoTesting_OneofWellKnownTypes: SwiftProtobuf.Message, SwiftPro
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    switch self.oneofField {
-    case .anyField?: try {
-      guard case .anyField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    }()
-    case .apiField?: try {
-      guard case .apiField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
-    }()
-    case .durationField?: try {
-      guard case .durationField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
-    }()
-    case .emptyField?: try {
-      guard case .emptyField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
-    }()
-    case .fieldMaskField?: try {
-      guard case .fieldMaskField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
-    }()
-    case .sourceContextField?: try {
-      guard case .sourceContextField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 6)
-    }()
-    case .structField?: try {
-      guard case .structField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
-    }()
-    case .timestampField?: try {
-      guard case .timestampField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
-    }()
-    case .typeField?: try {
-      guard case .typeField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 9)
-    }()
-    case .doubleField?: try {
-      guard case .doubleField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 10)
-    }()
-    case .floatField?: try {
-      guard case .floatField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 11)
-    }()
-    case .int64Field?: try {
-      guard case .int64Field(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 12)
-    }()
-    case .uint64Field?: try {
-      guard case .uint64Field(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 13)
-    }()
-    case .int32Field?: try {
-      guard case .int32Field(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 14)
-    }()
-    case .uint32Field?: try {
-      guard case .uint32Field(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 15)
-    }()
-    case .boolField?: try {
-      guard case .boolField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 16)
-    }()
-    case .stringField?: try {
-      guard case .stringField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 17)
-    }()
-    case .bytesField?: try {
-      guard case .bytesField(let v)? = self.oneofField else { preconditionFailure() }
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 18)
-    }()
-    case nil: break
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .oneOf({ $0.oneofField }) {
+      switch $0 {
+      case .anyField:
+        return _oneOfField_anyField
+      case .apiField:
+        return _oneOfField_apiField
+      case .durationField:
+        return _oneOfField_durationField
+      case .emptyField:
+        return _oneOfField_emptyField
+      case .fieldMaskField:
+        return _oneOfField_fieldMaskField
+      case .sourceContextField:
+        return _oneOfField_sourceContextField
+      case .structField:
+        return _oneOfField_structField
+      case .timestampField:
+        return _oneOfField_timestampField
+      case .typeField:
+        return _oneOfField_typeField
+      case .doubleField:
+        return _oneOfField_doubleField
+      case .floatField:
+        return _oneOfField_floatField
+      case .int64Field:
+        return _oneOfField_int64Field
+      case .uint64Field:
+        return _oneOfField_uint64Field
+      case .int32Field:
+        return _oneOfField_int32Field
+      case .uint32Field:
+        return _oneOfField_uint32Field
+      case .boolField:
+        return _oneOfField_boolField
+      case .stringField:
+        return _oneOfField_stringField
+      case .bytesField:
+        return _oneOfField_bytesField
+      }
+    },
+  ]
+  private static let _oneOfField_anyField: Field<Self> = .singularMessage({ $0.anyField }, fieldNumber: 1, isUnset: { _ in false })
+  private static let _oneOfField_apiField: Field<Self> = .singularMessage({ $0.apiField }, fieldNumber: 2, isUnset: { _ in false })
+  private static let _oneOfField_durationField: Field<Self> = .singularMessage({ $0.durationField }, fieldNumber: 3, isUnset: { _ in false })
+  private static let _oneOfField_emptyField: Field<Self> = .singularMessage({ $0.emptyField }, fieldNumber: 4, isUnset: { _ in false })
+  private static let _oneOfField_fieldMaskField: Field<Self> = .singularMessage({ $0.fieldMaskField }, fieldNumber: 5, isUnset: { _ in false })
+  private static let _oneOfField_sourceContextField: Field<Self> = .singularMessage({ $0.sourceContextField }, fieldNumber: 6, isUnset: { _ in false })
+  private static let _oneOfField_structField: Field<Self> = .singularMessage({ $0.structField }, fieldNumber: 7, isUnset: { _ in false })
+  private static let _oneOfField_timestampField: Field<Self> = .singularMessage({ $0.timestampField }, fieldNumber: 8, isUnset: { _ in false })
+  private static let _oneOfField_typeField: Field<Self> = .singularMessage({ $0.typeField }, fieldNumber: 9, isUnset: { _ in false })
+  private static let _oneOfField_doubleField: Field<Self> = .singularMessage({ $0.doubleField }, fieldNumber: 10, isUnset: { _ in false })
+  private static let _oneOfField_floatField: Field<Self> = .singularMessage({ $0.floatField }, fieldNumber: 11, isUnset: { _ in false })
+  private static let _oneOfField_int64Field: Field<Self> = .singularMessage({ $0.int64Field }, fieldNumber: 12, isUnset: { _ in false })
+  private static let _oneOfField_uint64Field: Field<Self> = .singularMessage({ $0.uint64Field }, fieldNumber: 13, isUnset: { _ in false })
+  private static let _oneOfField_int32Field: Field<Self> = .singularMessage({ $0.int32Field }, fieldNumber: 14, isUnset: { _ in false })
+  private static let _oneOfField_uint32Field: Field<Self> = .singularMessage({ $0.uint32Field }, fieldNumber: 15, isUnset: { _ in false })
+  private static let _oneOfField_boolField: Field<Self> = .singularMessage({ $0.boolField }, fieldNumber: 16, isUnset: { _ in false })
+  private static let _oneOfField_stringField: Field<Self> = .singularMessage({ $0.stringField }, fieldNumber: 17, isUnset: { _ in false })
+  private static let _oneOfField_bytesField: Field<Self> = .singularMessage({ $0.bytesField }, fieldNumber: 18, isUnset: { _ in false })
+
 
   static func ==(lhs: SwiftProtoTesting_OneofWellKnownTypes, rhs: SwiftProtoTesting_OneofWellKnownTypes) -> Bool {
     if lhs.oneofField != rhs.oneofField {return false}
@@ -1506,65 +1403,27 @@ extension SwiftProtoTesting_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProto
     }
   }
 
-  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
-      if !_storage._anyField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Any>.self, value: _storage._anyField, fieldNumber: 1)
-      }
-      if !_storage._apiField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Api>.self, value: _storage._apiField, fieldNumber: 2)
-      }
-      if !_storage._durationField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Duration>.self, value: _storage._durationField, fieldNumber: 3)
-      }
-      if !_storage._emptyField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Empty>.self, value: _storage._emptyField, fieldNumber: 4)
-      }
-      if !_storage._fieldMaskField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_FieldMask>.self, value: _storage._fieldMaskField, fieldNumber: 5)
-      }
-      if !_storage._sourceContextField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_SourceContext>.self, value: _storage._sourceContextField, fieldNumber: 6)
-      }
-      if !_storage._structField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Struct>.self, value: _storage._structField, fieldNumber: 7)
-      }
-      if !_storage._timestampField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Timestamp>.self, value: _storage._timestampField, fieldNumber: 8)
-      }
-      if !_storage._typeField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Type>.self, value: _storage._typeField, fieldNumber: 9)
-      }
-      if !_storage._doubleField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_DoubleValue>.self, value: _storage._doubleField, fieldNumber: 10)
-      }
-      if !_storage._floatField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_FloatValue>.self, value: _storage._floatField, fieldNumber: 11)
-      }
-      if !_storage._int64Field.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Int64Value>.self, value: _storage._int64Field, fieldNumber: 12)
-      }
-      if !_storage._uint64Field.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_UInt64Value>.self, value: _storage._uint64Field, fieldNumber: 13)
-      }
-      if !_storage._int32Field.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Int32Value>.self, value: _storage._int32Field, fieldNumber: 14)
-      }
-      if !_storage._uint32Field.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_UInt32Value>.self, value: _storage._uint32Field, fieldNumber: 15)
-      }
-      if !_storage._boolField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_BoolValue>.self, value: _storage._boolField, fieldNumber: 16)
-      }
-      if !_storage._stringField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_StringValue>.self, value: _storage._stringField, fieldNumber: 17)
-      }
-      if !_storage._bytesField.isEmpty {
-        try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_BytesValue>.self, value: _storage._bytesField, fieldNumber: 18)
-      }
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
+  static let _fields: [Field<Self>] = [
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Any>.self, { $0.anyField }, fieldNumber: 1),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Api>.self, { $0.apiField }, fieldNumber: 2),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Duration>.self, { $0.durationField }, fieldNumber: 3),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Empty>.self, { $0.emptyField }, fieldNumber: 4),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_FieldMask>.self, { $0.fieldMaskField }, fieldNumber: 5),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_SourceContext>.self, { $0.sourceContextField }, fieldNumber: 6),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Struct>.self, { $0.structField }, fieldNumber: 7),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Timestamp>.self, { $0.timestampField }, fieldNumber: 8),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Type>.self, { $0.typeField }, fieldNumber: 9),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_DoubleValue>.self, { $0.doubleField }, fieldNumber: 10),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_FloatValue>.self, { $0.floatField }, fieldNumber: 11),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Int64Value>.self, { $0.int64Field }, fieldNumber: 12),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_UInt64Value>.self, { $0.uint64Field }, fieldNumber: 13),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Int32Value>.self, { $0.int32Field }, fieldNumber: 14),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_UInt32Value>.self, { $0.uint32Field }, fieldNumber: 15),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_BoolValue>.self, { $0.boolField }, fieldNumber: 16),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_StringValue>.self, { $0.stringField }, fieldNumber: 17),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_BytesValue>.self, { $0.bytesField }, fieldNumber: 18),
+  ]
+
 
   static func ==(lhs: SwiftProtoTesting_MapWellKnownTypes, rhs: SwiftProtoTesting_MapWellKnownTypes) -> Bool {
     if lhs._storage !== rhs._storage {

From 0ee2fba39a02b3a68b868c95e27a8061e44e4f0d Mon Sep 17 00:00:00 2001
From: Max Rabiciuc <max.rabiciuc@robinhood.com>
Date: Fri, 1 Dec 2023 11:54:48 -0800
Subject: [PATCH 3/3] Implicit isUnset for message fields, and move _fields to
 _MessageImplementationBase

---
 .../Sources/FuzzCommon/fuzz_testing.pb.swift  | 426 +++++++++---------
 Sources/Conformance/conformance.pb.swift      |   2 +-
 .../Conformance/test_messages_proto2.pb.swift |  72 +--
 .../Conformance/test_messages_proto3.pb.swift | 114 ++---
 Sources/SwiftProtobuf/Field.swift             |  37 +-
 Sources/SwiftProtobuf/Message.swift           |  22 +-
 Sources/SwiftProtobuf/api.pb.swift            |   2 +-
 Sources/SwiftProtobuf/descriptor.pb.swift     |  60 +--
 Sources/SwiftProtobuf/struct.pb.swift         |   4 +-
 Sources/SwiftProtobuf/type.pb.swift           |   6 +-
 .../plugin.pb.swift                           |   4 +-
 .../MessageFieldGenerator.swift               |   6 +-
 Sources/protoc-gen-swift/OneofGenerator.swift |   3 +-
 Tests/SwiftProtobufTests/any_test.pb.swift    |   2 +-
 .../SwiftProtobufTests/fuzz_testing.pb.swift  | 426 +++++++++---------
 .../SwiftProtobufTests/map_unittest.pb.swift  |  38 +-
 .../test_messages_proto3.pb.swift             | 104 ++---
 Tests/SwiftProtobufTests/unittest.pb.swift    |  72 +--
 .../SwiftProtobufTests/unittest_mset.pb.swift |   4 +-
 .../unittest_proto3.pb.swift                  |  30 +-
 .../unittest_proto3_optional.pb.swift         |   4 +-
 ...unittest_swift_all_required_types.pb.swift |  14 +-
 .../unittest_swift_cycle.pb.swift             |  18 +-
 .../unittest_swift_deprecated.pb.swift        |   4 +-
 ...ttest_swift_enum_optional_default.pb.swift |   2 +-
 .../unittest_swift_extension.pb.swift         |   2 +-
 .../unittest_swift_fieldorder.pb.swift        |   2 +-
 .../unittest_swift_groups.pb.swift            |   4 +-
 .../unittest_swift_naming.pb.swift            |   4 +-
 ...unittest_swift_oneof_all_required.pb.swift |   6 +-
 .../unittest_swift_oneof_merging.pb.swift     |   4 +-
 .../unittest_swift_runtime_proto2.pb.swift    |  54 +--
 .../unittest_swift_runtime_proto3.pb.swift    |  48 +-
 .../unittest_well_known_types.pb.swift        | 146 +++---
 34 files changed, 885 insertions(+), 861 deletions(-)

diff --git a/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift b/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift
index ff5a7894f..89449845c 100644
--- a/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift
+++ b/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift
@@ -3869,8 +3869,8 @@ extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._
     .singularString({ $0.singularString }, fieldNumber: 14, isUnset: { $0._storage._singularString == nil }),
     .singularBytes({ $0.singularBytes }, fieldNumber: 15, isUnset: { $0._storage._singularBytes == nil }),
     .singularEnum({ $0.singularEnum }, fieldNumber: 16, isUnset: { $0._storage._singularEnum == nil }),
-    .singularGroup({ $0.singularGroup }, fieldNumber: 17, isUnset: { $0._storage._singularGroup == nil }),
-    .singularMessage({ $0.singularMessage }, fieldNumber: 19, isUnset: { $0._storage._singularMessage == nil }),
+    .singularGroup({ $0._storage._singularGroup }, fieldNumber: 17),
+    .singularMessage({ $0._storage._singularMessage }, fieldNumber: 19),
     .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
     .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
     .repeatedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
@@ -3887,8 +3887,8 @@ extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._
     .repeatedString({ $0.repeatedString }, fieldNumber: 44),
     .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
     .repeatedEnum({ $0.repeatedEnum }, fieldNumber: 46),
-    .repeatedGroup({ $0.repeatedGroup }, fieldNumber: 47),
-    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 49),
+    .repeatedGroup({ $0._storage._repeatedGroup }, fieldNumber: 47),
+    .repeatedMessage({ $0._storage._repeatedMessage }, fieldNumber: 49),
     .oneOf({ $0.o }) {
       switch $0 {
       case .oneofInt32:
@@ -3943,213 +3943,213 @@ extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._
     .packedDouble({ $0.repeatedPackedDouble }, fieldNumber: 92),
     .packedBool({ $0.repeatedPackedBool }, fieldNumber: 93),
     .packedEnum({ $0.repeatedPackedEnum }, fieldNumber: 94),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 100),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt32Int64 }, fieldNumber: 101),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapInt32Uint32 }, fieldNumber: 102),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapInt32Uint64 }, fieldNumber: 103),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapInt32Sint32 }, fieldNumber: 104),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapInt32Sint64 }, fieldNumber: 105),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapInt32Fixed32 }, fieldNumber: 106),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapInt32Fixed64 }, fieldNumber: 107),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapInt32Sfixed32 }, fieldNumber: 108),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapInt32Sfixed64 }, fieldNumber: 109),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 110),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 111),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapInt32Bool }, fieldNumber: 112),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapInt32String }, fieldNumber: 113),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt32Bytes }, fieldNumber: 114),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapInt32AnEnum }, fieldNumber: 115),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapInt32Message }, fieldNumber: 116),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt64Int32 }, fieldNumber: 117),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 118),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapInt64Uint32 }, fieldNumber: 119),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapInt64Uint64 }, fieldNumber: 120),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapInt64Sint32 }, fieldNumber: 121),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapInt64Sint64 }, fieldNumber: 122),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapInt64Fixed32 }, fieldNumber: 123),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapInt64Fixed64 }, fieldNumber: 124),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapInt64Sfixed32 }, fieldNumber: 125),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapInt64Sfixed64 }, fieldNumber: 126),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt64Float }, fieldNumber: 127),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt64Double }, fieldNumber: 128),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapInt64Bool }, fieldNumber: 129),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapInt64String }, fieldNumber: 130),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt64Bytes }, fieldNumber: 131),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapInt64AnEnum }, fieldNumber: 132),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapInt64Message }, fieldNumber: 133),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapUint32Int32 }, fieldNumber: 134),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapUint32Int64 }, fieldNumber: 135),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 136),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint32Uint64 }, fieldNumber: 137),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapUint32Sint32 }, fieldNumber: 138),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapUint32Sint64 }, fieldNumber: 139),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapUint32Fixed32 }, fieldNumber: 140),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapUint32Fixed64 }, fieldNumber: 141),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapUint32Sfixed32 }, fieldNumber: 142),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapUint32Sfixed64 }, fieldNumber: 143),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapUint32Float }, fieldNumber: 144),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapUint32Double }, fieldNumber: 145),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapUint32Bool }, fieldNumber: 146),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapUint32String }, fieldNumber: 147),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapUint32Bytes }, fieldNumber: 148),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapUint32AnEnum }, fieldNumber: 149),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapUint32Message }, fieldNumber: 150),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapUint64Int32 }, fieldNumber: 151),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapUint64Int64 }, fieldNumber: 152),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint64Uint32 }, fieldNumber: 153),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 154),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapUint64Sint32 }, fieldNumber: 155),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapUint64Sint64 }, fieldNumber: 156),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapUint64Fixed32 }, fieldNumber: 157),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapUint64Fixed64 }, fieldNumber: 158),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapUint64Sfixed32 }, fieldNumber: 159),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapUint64Sfixed64 }, fieldNumber: 160),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapUint64Float }, fieldNumber: 161),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapUint64Double }, fieldNumber: 162),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapUint64Bool }, fieldNumber: 163),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapUint64String }, fieldNumber: 164),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapUint64Bytes }, fieldNumber: 165),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapUint64AnEnum }, fieldNumber: 166),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapUint64Message }, fieldNumber: 167),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSint32Int32 }, fieldNumber: 168),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSint32Int64 }, fieldNumber: 169),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSint32Uint32 }, fieldNumber: 170),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSint32Uint64 }, fieldNumber: 171),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 172),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint32Sint64 }, fieldNumber: 173),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSint32Fixed32 }, fieldNumber: 174),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSint32Fixed64 }, fieldNumber: 175),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSint32Sfixed32 }, fieldNumber: 176),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSint32Sfixed64 }, fieldNumber: 177),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSint32Float }, fieldNumber: 178),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSint32Double }, fieldNumber: 179),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapSint32Bool }, fieldNumber: 180),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapSint32String }, fieldNumber: 181),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSint32Bytes }, fieldNumber: 182),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSint32AnEnum }, fieldNumber: 183),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSint32Message }, fieldNumber: 184),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSint64Int32 }, fieldNumber: 185),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSint64Int64 }, fieldNumber: 186),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSint64Uint32 }, fieldNumber: 187),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSint64Uint64 }, fieldNumber: 188),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint64Sint32 }, fieldNumber: 189),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 190),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSint64Fixed32 }, fieldNumber: 191),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSint64Fixed64 }, fieldNumber: 192),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSint64Sfixed32 }, fieldNumber: 193),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSint64Sfixed64 }, fieldNumber: 194),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSint64Float }, fieldNumber: 195),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSint64Double }, fieldNumber: 196),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapSint64Bool }, fieldNumber: 197),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapSint64String }, fieldNumber: 198),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSint64Bytes }, fieldNumber: 199),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSint64AnEnum }, fieldNumber: 200),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSint64Message }, fieldNumber: 201),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapFixed32Int32 }, fieldNumber: 202),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapFixed32Int64 }, fieldNumber: 203),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapFixed32Uint32 }, fieldNumber: 204),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapFixed32Uint64 }, fieldNumber: 205),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapFixed32Sint32 }, fieldNumber: 206),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapFixed32Sint64 }, fieldNumber: 207),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 208),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed32Fixed64 }, fieldNumber: 209),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapFixed32Sfixed32 }, fieldNumber: 210),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapFixed32Sfixed64 }, fieldNumber: 211),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapFixed32Float }, fieldNumber: 212),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapFixed32Double }, fieldNumber: 213),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBool>.self, { $0.mapFixed32Bool }, fieldNumber: 214),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufString>.self, { $0.mapFixed32String }, fieldNumber: 215),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapFixed32Bytes }, fieldNumber: 216),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapFixed32AnEnum }, fieldNumber: 217),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapFixed32Message }, fieldNumber: 218),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapFixed64Int32 }, fieldNumber: 219),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapFixed64Int64 }, fieldNumber: 220),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapFixed64Uint32 }, fieldNumber: 221),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapFixed64Uint64 }, fieldNumber: 222),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapFixed64Sint32 }, fieldNumber: 223),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapFixed64Sint64 }, fieldNumber: 224),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed64Fixed32 }, fieldNumber: 225),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 226),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapFixed64Sfixed32 }, fieldNumber: 227),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapFixed64Sfixed64 }, fieldNumber: 228),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapFixed64Float }, fieldNumber: 229),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapFixed64Double }, fieldNumber: 230),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBool>.self, { $0.mapFixed64Bool }, fieldNumber: 231),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufString>.self, { $0.mapFixed64String }, fieldNumber: 232),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapFixed64Bytes }, fieldNumber: 233),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapFixed64AnEnum }, fieldNumber: 234),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapFixed64Message }, fieldNumber: 235),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSfixed32Int32 }, fieldNumber: 236),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSfixed32Int64 }, fieldNumber: 237),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSfixed32Uint32 }, fieldNumber: 238),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSfixed32Uint64 }, fieldNumber: 239),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSfixed32Sint32 }, fieldNumber: 240),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSfixed32Sint64 }, fieldNumber: 241),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSfixed32Fixed32 }, fieldNumber: 242),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSfixed32Fixed64 }, fieldNumber: 243),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 244),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed32Sfixed64 }, fieldNumber: 245),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSfixed32Float }, fieldNumber: 246),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSfixed32Double }, fieldNumber: 247),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBool>.self, { $0.mapSfixed32Bool }, fieldNumber: 248),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufString>.self, { $0.mapSfixed32String }, fieldNumber: 249),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSfixed32Bytes }, fieldNumber: 250),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSfixed32AnEnum }, fieldNumber: 251),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSfixed32Message }, fieldNumber: 252),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSfixed64Int32 }, fieldNumber: 253),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSfixed64Int64 }, fieldNumber: 254),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSfixed64Uint32 }, fieldNumber: 255),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSfixed64Uint64 }, fieldNumber: 256),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSfixed64Sint32 }, fieldNumber: 257),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSfixed64Sint64 }, fieldNumber: 258),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSfixed64Fixed32 }, fieldNumber: 259),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSfixed64Fixed64 }, fieldNumber: 260),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed64Sfixed32 }, fieldNumber: 261),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 262),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSfixed64Float }, fieldNumber: 263),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSfixed64Double }, fieldNumber: 264),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBool>.self, { $0.mapSfixed64Bool }, fieldNumber: 265),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufString>.self, { $0.mapSfixed64String }, fieldNumber: 266),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSfixed64Bytes }, fieldNumber: 267),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSfixed64AnEnum }, fieldNumber: 268),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSfixed64Message }, fieldNumber: 269),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt32>.self, { $0.mapBoolInt32 }, fieldNumber: 270),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt64>.self, { $0.mapBoolInt64 }, fieldNumber: 271),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapBoolUint32 }, fieldNumber: 272),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapBoolUint64 }, fieldNumber: 273),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapBoolSint32 }, fieldNumber: 274),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapBoolSint64 }, fieldNumber: 275),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapBoolFixed32 }, fieldNumber: 276),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapBoolFixed64 }, fieldNumber: 277),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapBoolSfixed32 }, fieldNumber: 278),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapBoolSfixed64 }, fieldNumber: 279),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFloat>.self, { $0.mapBoolFloat }, fieldNumber: 280),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufDouble>.self, { $0.mapBoolDouble }, fieldNumber: 281),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 282),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufString>.self, { $0.mapBoolString }, fieldNumber: 283),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBytes>.self, { $0.mapBoolBytes }, fieldNumber: 284),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapBoolAnEnum }, fieldNumber: 285),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapBoolMessage }, fieldNumber: 286),
-    .singularMessage({ $0.wktAny }, fieldNumber: 500, isUnset: { $0._storage._wktAny == nil }),
-    .singularMessage({ $0.wktApi }, fieldNumber: 501, isUnset: { $0._storage._wktApi == nil }),
-    .singularMessage({ $0.wktDuration }, fieldNumber: 502, isUnset: { $0._storage._wktDuration == nil }),
-    .singularMessage({ $0.wktEmpty }, fieldNumber: 503, isUnset: { $0._storage._wktEmpty == nil }),
-    .singularMessage({ $0.wktFieldMask }, fieldNumber: 504, isUnset: { $0._storage._wktFieldMask == nil }),
-    .singularMessage({ $0.wktSourceContext }, fieldNumber: 505, isUnset: { $0._storage._wktSourceContext == nil }),
-    .singularMessage({ $0.wktStruct }, fieldNumber: 506, isUnset: { $0._storage._wktStruct == nil }),
-    .singularMessage({ $0.wktTimestamp }, fieldNumber: 507, isUnset: { $0._storage._wktTimestamp == nil }),
-    .singularMessage({ $0.wktType }, fieldNumber: 508, isUnset: { $0._storage._wktType == nil }),
-    .singularMessage({ $0.wktDoubleValue }, fieldNumber: 509, isUnset: { $0._storage._wktDoubleValue == nil }),
-    .singularMessage({ $0.wktFloatValue }, fieldNumber: 510, isUnset: { $0._storage._wktFloatValue == nil }),
-    .singularMessage({ $0.wktInt64Value }, fieldNumber: 511, isUnset: { $0._storage._wktInt64Value == nil }),
-    .singularMessage({ $0.wktUint64Value }, fieldNumber: 512, isUnset: { $0._storage._wktUint64Value == nil }),
-    .singularMessage({ $0.wktInt32Value }, fieldNumber: 513, isUnset: { $0._storage._wktInt32Value == nil }),
-    .singularMessage({ $0.wktUint32Value }, fieldNumber: 514, isUnset: { $0._storage._wktUint32Value == nil }),
-    .singularMessage({ $0.wktBoolValue }, fieldNumber: 515, isUnset: { $0._storage._wktBoolValue == nil }),
-    .singularMessage({ $0.wktStringValue }, fieldNumber: 516, isUnset: { $0._storage._wktStringValue == nil }),
-    .singularMessage({ $0.wktBytesValue }, fieldNumber: 517, isUnset: { $0._storage._wktBytesValue == nil }),
-    .singularMessage({ $0.singularMessageSet }, fieldNumber: 600, isUnset: { $0._storage._singularMessageSet == nil }),
-    .repeatedMessage({ $0.repeatedMessageSet }, fieldNumber: 601),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapInt32Int32 }, fieldNumber: 100),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapInt32Int64 }, fieldNumber: 101),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapInt32Uint32 }, fieldNumber: 102),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapInt32Uint64 }, fieldNumber: 103),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapInt32Sint32 }, fieldNumber: 104),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapInt32Sint64 }, fieldNumber: 105),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapInt32Fixed32 }, fieldNumber: 106),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapInt32Fixed64 }, fieldNumber: 107),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapInt32Sfixed32 }, fieldNumber: 108),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapInt32Sfixed64 }, fieldNumber: 109),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapInt32Float }, fieldNumber: 110),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapInt32Double }, fieldNumber: 111),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapInt32Bool }, fieldNumber: 112),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapInt32String }, fieldNumber: 113),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapInt32Bytes }, fieldNumber: 114),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapInt32AnEnum }, fieldNumber: 115),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapInt32Message }, fieldNumber: 116),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapInt64Int32 }, fieldNumber: 117),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapInt64Int64 }, fieldNumber: 118),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapInt64Uint32 }, fieldNumber: 119),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapInt64Uint64 }, fieldNumber: 120),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapInt64Sint32 }, fieldNumber: 121),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapInt64Sint64 }, fieldNumber: 122),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapInt64Fixed32 }, fieldNumber: 123),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapInt64Fixed64 }, fieldNumber: 124),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapInt64Sfixed32 }, fieldNumber: 125),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapInt64Sfixed64 }, fieldNumber: 126),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapInt64Float }, fieldNumber: 127),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapInt64Double }, fieldNumber: 128),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapInt64Bool }, fieldNumber: 129),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapInt64String }, fieldNumber: 130),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapInt64Bytes }, fieldNumber: 131),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapInt64AnEnum }, fieldNumber: 132),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapInt64Message }, fieldNumber: 133),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapUint32Int32 }, fieldNumber: 134),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapUint32Int64 }, fieldNumber: 135),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapUint32Uint32 }, fieldNumber: 136),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapUint32Uint64 }, fieldNumber: 137),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapUint32Sint32 }, fieldNumber: 138),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapUint32Sint64 }, fieldNumber: 139),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapUint32Fixed32 }, fieldNumber: 140),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapUint32Fixed64 }, fieldNumber: 141),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapUint32Sfixed32 }, fieldNumber: 142),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapUint32Sfixed64 }, fieldNumber: 143),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapUint32Float }, fieldNumber: 144),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapUint32Double }, fieldNumber: 145),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapUint32Bool }, fieldNumber: 146),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapUint32String }, fieldNumber: 147),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapUint32Bytes }, fieldNumber: 148),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapUint32AnEnum }, fieldNumber: 149),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapUint32Message }, fieldNumber: 150),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapUint64Int32 }, fieldNumber: 151),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapUint64Int64 }, fieldNumber: 152),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapUint64Uint32 }, fieldNumber: 153),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapUint64Uint64 }, fieldNumber: 154),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapUint64Sint32 }, fieldNumber: 155),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapUint64Sint64 }, fieldNumber: 156),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapUint64Fixed32 }, fieldNumber: 157),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapUint64Fixed64 }, fieldNumber: 158),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapUint64Sfixed32 }, fieldNumber: 159),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapUint64Sfixed64 }, fieldNumber: 160),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapUint64Float }, fieldNumber: 161),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapUint64Double }, fieldNumber: 162),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapUint64Bool }, fieldNumber: 163),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapUint64String }, fieldNumber: 164),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapUint64Bytes }, fieldNumber: 165),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapUint64AnEnum }, fieldNumber: 166),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapUint64Message }, fieldNumber: 167),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapSint32Int32 }, fieldNumber: 168),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapSint32Int64 }, fieldNumber: 169),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapSint32Uint32 }, fieldNumber: 170),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapSint32Uint64 }, fieldNumber: 171),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSint32Sint32 }, fieldNumber: 172),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSint32Sint64 }, fieldNumber: 173),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapSint32Fixed32 }, fieldNumber: 174),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapSint32Fixed64 }, fieldNumber: 175),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSint32Sfixed32 }, fieldNumber: 176),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSint32Sfixed64 }, fieldNumber: 177),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapSint32Float }, fieldNumber: 178),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapSint32Double }, fieldNumber: 179),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapSint32Bool }, fieldNumber: 180),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapSint32String }, fieldNumber: 181),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapSint32Bytes }, fieldNumber: 182),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapSint32AnEnum }, fieldNumber: 183),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapSint32Message }, fieldNumber: 184),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapSint64Int32 }, fieldNumber: 185),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapSint64Int64 }, fieldNumber: 186),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapSint64Uint32 }, fieldNumber: 187),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapSint64Uint64 }, fieldNumber: 188),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSint64Sint32 }, fieldNumber: 189),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSint64Sint64 }, fieldNumber: 190),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapSint64Fixed32 }, fieldNumber: 191),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapSint64Fixed64 }, fieldNumber: 192),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSint64Sfixed32 }, fieldNumber: 193),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSint64Sfixed64 }, fieldNumber: 194),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapSint64Float }, fieldNumber: 195),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapSint64Double }, fieldNumber: 196),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapSint64Bool }, fieldNumber: 197),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapSint64String }, fieldNumber: 198),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapSint64Bytes }, fieldNumber: 199),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapSint64AnEnum }, fieldNumber: 200),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapSint64Message }, fieldNumber: 201),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapFixed32Int32 }, fieldNumber: 202),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapFixed32Int64 }, fieldNumber: 203),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapFixed32Uint32 }, fieldNumber: 204),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapFixed32Uint64 }, fieldNumber: 205),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapFixed32Sint32 }, fieldNumber: 206),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapFixed32Sint64 }, fieldNumber: 207),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapFixed32Fixed32 }, fieldNumber: 208),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapFixed32Fixed64 }, fieldNumber: 209),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapFixed32Sfixed32 }, fieldNumber: 210),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapFixed32Sfixed64 }, fieldNumber: 211),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapFixed32Float }, fieldNumber: 212),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapFixed32Double }, fieldNumber: 213),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapFixed32Bool }, fieldNumber: 214),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapFixed32String }, fieldNumber: 215),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapFixed32Bytes }, fieldNumber: 216),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapFixed32AnEnum }, fieldNumber: 217),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapFixed32Message }, fieldNumber: 218),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapFixed64Int32 }, fieldNumber: 219),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapFixed64Int64 }, fieldNumber: 220),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapFixed64Uint32 }, fieldNumber: 221),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapFixed64Uint64 }, fieldNumber: 222),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapFixed64Sint32 }, fieldNumber: 223),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapFixed64Sint64 }, fieldNumber: 224),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapFixed64Fixed32 }, fieldNumber: 225),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapFixed64Fixed64 }, fieldNumber: 226),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapFixed64Sfixed32 }, fieldNumber: 227),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapFixed64Sfixed64 }, fieldNumber: 228),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapFixed64Float }, fieldNumber: 229),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapFixed64Double }, fieldNumber: 230),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapFixed64Bool }, fieldNumber: 231),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapFixed64String }, fieldNumber: 232),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapFixed64Bytes }, fieldNumber: 233),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapFixed64AnEnum }, fieldNumber: 234),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapFixed64Message }, fieldNumber: 235),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapSfixed32Int32 }, fieldNumber: 236),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapSfixed32Int64 }, fieldNumber: 237),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapSfixed32Uint32 }, fieldNumber: 238),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapSfixed32Uint64 }, fieldNumber: 239),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSfixed32Sint32 }, fieldNumber: 240),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSfixed32Sint64 }, fieldNumber: 241),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapSfixed32Fixed32 }, fieldNumber: 242),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapSfixed32Fixed64 }, fieldNumber: 243),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSfixed32Sfixed32 }, fieldNumber: 244),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSfixed32Sfixed64 }, fieldNumber: 245),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapSfixed32Float }, fieldNumber: 246),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapSfixed32Double }, fieldNumber: 247),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapSfixed32Bool }, fieldNumber: 248),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapSfixed32String }, fieldNumber: 249),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapSfixed32Bytes }, fieldNumber: 250),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapSfixed32AnEnum }, fieldNumber: 251),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapSfixed32Message }, fieldNumber: 252),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapSfixed64Int32 }, fieldNumber: 253),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapSfixed64Int64 }, fieldNumber: 254),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapSfixed64Uint32 }, fieldNumber: 255),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapSfixed64Uint64 }, fieldNumber: 256),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSfixed64Sint32 }, fieldNumber: 257),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSfixed64Sint64 }, fieldNumber: 258),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapSfixed64Fixed32 }, fieldNumber: 259),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapSfixed64Fixed64 }, fieldNumber: 260),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSfixed64Sfixed32 }, fieldNumber: 261),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSfixed64Sfixed64 }, fieldNumber: 262),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapSfixed64Float }, fieldNumber: 263),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapSfixed64Double }, fieldNumber: 264),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapSfixed64Bool }, fieldNumber: 265),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapSfixed64String }, fieldNumber: 266),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapSfixed64Bytes }, fieldNumber: 267),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapSfixed64AnEnum }, fieldNumber: 268),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapSfixed64Message }, fieldNumber: 269),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapBoolInt32 }, fieldNumber: 270),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapBoolInt64 }, fieldNumber: 271),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapBoolUint32 }, fieldNumber: 272),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapBoolUint64 }, fieldNumber: 273),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapBoolSint32 }, fieldNumber: 274),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapBoolSint64 }, fieldNumber: 275),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapBoolFixed32 }, fieldNumber: 276),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapBoolFixed64 }, fieldNumber: 277),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapBoolSfixed32 }, fieldNumber: 278),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapBoolSfixed64 }, fieldNumber: 279),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapBoolFloat }, fieldNumber: 280),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapBoolDouble }, fieldNumber: 281),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapBoolBool }, fieldNumber: 282),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapBoolString }, fieldNumber: 283),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapBoolBytes }, fieldNumber: 284),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapBoolAnEnum }, fieldNumber: 285),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapBoolMessage }, fieldNumber: 286),
+    .singularMessage({ $0._storage._wktAny }, fieldNumber: 500),
+    .singularMessage({ $0._storage._wktApi }, fieldNumber: 501),
+    .singularMessage({ $0._storage._wktDuration }, fieldNumber: 502),
+    .singularMessage({ $0._storage._wktEmpty }, fieldNumber: 503),
+    .singularMessage({ $0._storage._wktFieldMask }, fieldNumber: 504),
+    .singularMessage({ $0._storage._wktSourceContext }, fieldNumber: 505),
+    .singularMessage({ $0._storage._wktStruct }, fieldNumber: 506),
+    .singularMessage({ $0._storage._wktTimestamp }, fieldNumber: 507),
+    .singularMessage({ $0._storage._wktType }, fieldNumber: 508),
+    .singularMessage({ $0._storage._wktDoubleValue }, fieldNumber: 509),
+    .singularMessage({ $0._storage._wktFloatValue }, fieldNumber: 510),
+    .singularMessage({ $0._storage._wktInt64Value }, fieldNumber: 511),
+    .singularMessage({ $0._storage._wktUint64Value }, fieldNumber: 512),
+    .singularMessage({ $0._storage._wktInt32Value }, fieldNumber: 513),
+    .singularMessage({ $0._storage._wktUint32Value }, fieldNumber: 514),
+    .singularMessage({ $0._storage._wktBoolValue }, fieldNumber: 515),
+    .singularMessage({ $0._storage._wktStringValue }, fieldNumber: 516),
+    .singularMessage({ $0._storage._wktBytesValue }, fieldNumber: 517),
+    .singularMessage({ $0._storage._singularMessageSet }, fieldNumber: 600),
+    .repeatedMessage({ $0._storage._repeatedMessageSet }, fieldNumber: 601),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 2001),
   ]
   private static let _oneOfField_oneofInt32: Field<Self> = .singularInt32({ $0.oneofInt32 }, fieldNumber: 61, isUnset: { _ in false })
@@ -4168,8 +4168,8 @@ extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 74, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 75, isUnset: { _ in false })
   private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 76, isUnset: { _ in false })
-  private static let _oneOfField_oneofGroup: Field<Self> = .singularGroup({ $0.oneofGroup }, fieldNumber: 77, isUnset: { _ in false })
-  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 79, isUnset: { _ in false })
+  private static let _oneOfField_oneofGroup: Field<Self> = .singularGroup({ $0.oneofGroup }, fieldNumber: 77)
+  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 79)
 
 
   public static func ==(lhs: SwiftProtoTesting_Fuzz_Message, rhs: SwiftProtoTesting_Fuzz_Message) -> Bool {
diff --git a/Sources/Conformance/conformance.pb.swift b/Sources/Conformance/conformance.pb.swift
index ef8e0e3b7..b44e22ce8 100644
--- a/Sources/Conformance/conformance.pb.swift
+++ b/Sources/Conformance/conformance.pb.swift
@@ -543,7 +543,7 @@ extension Conformance_ConformanceRequest: SwiftProtobuf.Message, SwiftProtobuf._
     .singularEnum({ $0.requestedOutputFormat }, fieldNumber: 3, defaultValue: .unspecified),
     .singularString({ $0.messageType }, fieldNumber: 4),
     .singularEnum({ $0.testCategory }, fieldNumber: 5, defaultValue: .unspecifiedTest),
-    .singularMessage({ $0.jspbEncodingOptions }, fieldNumber: 6, isUnset: { $0._jspbEncodingOptions == nil }),
+    .singularMessage({ $0._jspbEncodingOptions }, fieldNumber: 6),
     .oneOf({ $0.payload }) {
       switch $0 {
       case .jspbPayload:
diff --git a/Sources/Conformance/test_messages_proto2.pb.swift b/Sources/Conformance/test_messages_proto2.pb.swift
index 881df1e34..f74431a05 100644
--- a/Sources/Conformance/test_messages_proto2.pb.swift
+++ b/Sources/Conformance/test_messages_proto2.pb.swift
@@ -2726,13 +2726,13 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message,
     .singularBool({ $0.optionalBool }, fieldNumber: 13, isUnset: { $0._storage._optionalBool == nil }),
     .singularString({ $0.optionalString }, fieldNumber: 14, isUnset: { $0._storage._optionalString == nil }),
     .singularBytes({ $0.optionalBytes }, fieldNumber: 15, isUnset: { $0._storage._optionalBytes == nil }),
-    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
-    .singularMessage({ $0.optionalForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._optionalForeignMessage == nil }),
+    .singularMessage({ $0._storage._optionalNestedMessage }, fieldNumber: 18),
+    .singularMessage({ $0._storage._optionalForeignMessage }, fieldNumber: 19),
     .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, isUnset: { $0._storage._optionalNestedEnum == nil }),
     .singularEnum({ $0.optionalForeignEnum }, fieldNumber: 22, isUnset: { $0._storage._optionalForeignEnum == nil }),
     .singularString({ $0.optionalStringPiece }, fieldNumber: 24, isUnset: { $0._storage._optionalStringPiece == nil }),
     .singularString({ $0.optionalCord }, fieldNumber: 25, isUnset: { $0._storage._optionalCord == nil }),
-    .singularMessage({ $0.recursiveMessage }, fieldNumber: 27, isUnset: { $0._storage._recursiveMessage == nil }),
+    .singularMessage({ $0._storage._recursiveMessage }, fieldNumber: 27),
     .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
     .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
     .repeatedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
@@ -2748,31 +2748,31 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message,
     .repeatedBool({ $0.repeatedBool }, fieldNumber: 43),
     .repeatedString({ $0.repeatedString }, fieldNumber: 44),
     .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
-    .repeatedMessage({ $0.repeatedNestedMessage }, fieldNumber: 48),
-    .repeatedMessage({ $0.repeatedForeignMessage }, fieldNumber: 49),
+    .repeatedMessage({ $0._storage._repeatedNestedMessage }, fieldNumber: 48),
+    .repeatedMessage({ $0._storage._repeatedForeignMessage }, fieldNumber: 49),
     .repeatedEnum({ $0.repeatedNestedEnum }, fieldNumber: 51),
     .repeatedEnum({ $0.repeatedForeignEnum }, fieldNumber: 52),
     .repeatedString({ $0.repeatedStringPiece }, fieldNumber: 54),
     .repeatedString({ $0.repeatedCord }, fieldNumber: 55),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 56),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 57),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 58),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 59),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 60),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 61),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 62),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 63),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 64),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 65),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 66),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 67),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 68),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 69),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0.mapStringBytes }, fieldNumber: 70),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage>.self, { $0.mapStringNestedMessage }, fieldNumber: 71),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_ForeignMessageProto2>.self, { $0.mapStringForeignMessage }, fieldNumber: 72),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum>.self, { $0.mapStringNestedEnum }, fieldNumber: 73),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_ForeignEnumProto2>.self, { $0.mapStringForeignEnum }, fieldNumber: 74),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapInt32Int32 }, fieldNumber: 56),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapInt64Int64 }, fieldNumber: 57),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapUint32Uint32 }, fieldNumber: 58),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapUint64Uint64 }, fieldNumber: 59),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSint32Sint32 }, fieldNumber: 60),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSint64Sint64 }, fieldNumber: 61),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapFixed32Fixed32 }, fieldNumber: 62),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapFixed64Fixed64 }, fieldNumber: 63),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSfixed32Sfixed32 }, fieldNumber: 64),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSfixed64Sfixed64 }, fieldNumber: 65),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapInt32Float }, fieldNumber: 66),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapInt32Double }, fieldNumber: 67),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapBoolBool }, fieldNumber: 68),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapStringString }, fieldNumber: 69),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapStringBytes }, fieldNumber: 70),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage>.self, { $0._storage._mapStringNestedMessage }, fieldNumber: 71),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_ForeignMessageProto2>.self, { $0._storage._mapStringForeignMessage }, fieldNumber: 72),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum>.self, { $0._storage._mapStringNestedEnum }, fieldNumber: 73),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto2_ForeignEnumProto2>.self, { $0._storage._mapStringForeignEnum }, fieldNumber: 74),
     .packedInt32({ $0.packedInt32 }, fieldNumber: 75),
     .packedInt64({ $0.packedInt64 }, fieldNumber: 76),
     .packedUInt32({ $0.packedUint32 }, fieldNumber: 77),
@@ -2824,7 +2824,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message,
       }
     },
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 120, end: 201),
-    .singularGroup({ $0.data }, fieldNumber: 201, isUnset: { $0._storage._data == nil }),
+    .singularGroup({ $0._storage._data }, fieldNumber: 201),
     .singularInt32({ $0.defaultInt32 }, fieldNumber: 241, isUnset: { $0._storage._defaultInt32 == nil }),
     .singularInt64({ $0.defaultInt64 }, fieldNumber: 242, isUnset: { $0._storage._defaultInt64 == nil }),
     .singularUInt32({ $0.defaultUint32 }, fieldNumber: 243, isUnset: { $0._storage._defaultUint32 == nil }),
@@ -2860,7 +2860,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message,
     .singularInt32({ $0.fieldName18__ }, fieldNumber: 418, isUnset: { $0._storage._fieldName18__ == nil }),
   ]
   private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
-  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112)
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
   private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 115, isUnset: { _ in false })
@@ -3072,7 +3072,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftPro
 
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._storage._a == nil }),
-    .singularMessage({ $0.corecursive }, fieldNumber: 2, isUnset: { $0._storage._corecursive == nil }),
+    .singularMessage({ $0._storage._corecursive }, fieldNumber: 2),
   ]
 
 
@@ -3272,8 +3272,8 @@ extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Messa
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.optionalInt32 }, fieldNumber: 1001, isUnset: { $0._optionalInt32 == nil }),
     .singularString({ $0.optionalString }, fieldNumber: 1002, isUnset: { $0._optionalString == nil }),
-    .singularMessage({ $0.nestedMessage }, fieldNumber: 1003, isUnset: { $0._nestedMessage == nil }),
-    .singularGroup({ $0.optionalGroup }, fieldNumber: 1004, isUnset: { $0._optionalGroup == nil }),
+    .singularMessage({ $0._nestedMessage }, fieldNumber: 1003),
+    .singularGroup({ $0._optionalGroup }, fieldNumber: 1004),
     .singularBool({ $0.optionalBool }, fieldNumber: 1006, isUnset: { $0._optionalBool == nil }),
     .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 1011),
   ]
@@ -3693,16 +3693,16 @@ extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.
     .singularBool({ $0.requiredBool }, fieldNumber: 13, isUnset: { $0._storage._requiredBool == nil }),
     .singularString({ $0.requiredString }, fieldNumber: 14, isUnset: { $0._storage._requiredString == nil }),
     .singularBytes({ $0.requiredBytes }, fieldNumber: 15, isUnset: { $0._storage._requiredBytes == nil }),
-    .singularMessage({ $0.requiredNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._requiredNestedMessage == nil }),
-    .singularMessage({ $0.requiredForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._requiredForeignMessage == nil }),
+    .singularMessage({ $0._storage._requiredNestedMessage }, fieldNumber: 18),
+    .singularMessage({ $0._storage._requiredForeignMessage }, fieldNumber: 19),
     .singularEnum({ $0.requiredNestedEnum }, fieldNumber: 21, isUnset: { $0._storage._requiredNestedEnum == nil }),
     .singularEnum({ $0.requiredForeignEnum }, fieldNumber: 22, isUnset: { $0._storage._requiredForeignEnum == nil }),
     .singularString({ $0.requiredStringPiece }, fieldNumber: 24, isUnset: { $0._storage._requiredStringPiece == nil }),
     .singularString({ $0.requiredCord }, fieldNumber: 25, isUnset: { $0._storage._requiredCord == nil }),
-    .singularMessage({ $0.recursiveMessage }, fieldNumber: 27, isUnset: { $0._storage._recursiveMessage == nil }),
-    .singularMessage({ $0.optionalRecursiveMessage }, fieldNumber: 28, isUnset: { $0._storage._optionalRecursiveMessage == nil }),
+    .singularMessage({ $0._storage._recursiveMessage }, fieldNumber: 27),
+    .singularMessage({ $0._storage._optionalRecursiveMessage }, fieldNumber: 28),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 120, end: 201),
-    .singularGroup({ $0.data }, fieldNumber: 201, isUnset: { $0._storage._data == nil }),
+    .singularGroup({ $0._storage._data }, fieldNumber: 201),
     .singularInt32({ $0.defaultInt32 }, fieldNumber: 241, isUnset: { $0._storage._defaultInt32 == nil }),
     .singularInt64({ $0.defaultInt64 }, fieldNumber: 242, isUnset: { $0._storage._defaultInt64 == nil }),
     .singularUInt32({ $0.defaultUint32 }, fieldNumber: 243, isUnset: { $0._storage._defaultUint32 == nil }),
@@ -3844,8 +3844,8 @@ extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage:
 
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.a }, fieldNumber: 1, isUnset: { $0._storage._a == nil }),
-    .singularMessage({ $0.corecursive }, fieldNumber: 2, isUnset: { $0._storage._corecursive == nil }),
-    .singularMessage({ $0.optionalCorecursive }, fieldNumber: 3, isUnset: { $0._storage._optionalCorecursive == nil }),
+    .singularMessage({ $0._storage._corecursive }, fieldNumber: 2),
+    .singularMessage({ $0._storage._optionalCorecursive }, fieldNumber: 3),
   ]
 
 
diff --git a/Sources/Conformance/test_messages_proto3.pb.swift b/Sources/Conformance/test_messages_proto3.pb.swift
index e571c765e..3338c08a1 100644
--- a/Sources/Conformance/test_messages_proto3.pb.swift
+++ b/Sources/Conformance/test_messages_proto3.pb.swift
@@ -1875,14 +1875,14 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message,
     .singularBool({ $0.optionalBool }, fieldNumber: 13),
     .singularString({ $0.optionalString }, fieldNumber: 14),
     .singularBytes({ $0.optionalBytes }, fieldNumber: 15),
-    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
-    .singularMessage({ $0.optionalForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._optionalForeignMessage == nil }),
+    .singularMessage({ $0._storage._optionalNestedMessage }, fieldNumber: 18),
+    .singularMessage({ $0._storage._optionalForeignMessage }, fieldNumber: 19),
     .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, defaultValue: .foo),
     .singularEnum({ $0.optionalForeignEnum }, fieldNumber: 22, defaultValue: .foreignFoo),
     .singularEnum({ $0.optionalAliasedEnum }, fieldNumber: 23, defaultValue: .aliasFoo),
     .singularString({ $0.optionalStringPiece }, fieldNumber: 24),
     .singularString({ $0.optionalCord }, fieldNumber: 25),
-    .singularMessage({ $0.recursiveMessage }, fieldNumber: 27, isUnset: { $0._storage._recursiveMessage == nil }),
+    .singularMessage({ $0._storage._recursiveMessage }, fieldNumber: 27),
     .packedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
     .packedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
     .packedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
@@ -1898,31 +1898,31 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message,
     .packedBool({ $0.repeatedBool }, fieldNumber: 43),
     .repeatedString({ $0.repeatedString }, fieldNumber: 44),
     .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
-    .repeatedMessage({ $0.repeatedNestedMessage }, fieldNumber: 48),
-    .repeatedMessage({ $0.repeatedForeignMessage }, fieldNumber: 49),
+    .repeatedMessage({ $0._storage._repeatedNestedMessage }, fieldNumber: 48),
+    .repeatedMessage({ $0._storage._repeatedForeignMessage }, fieldNumber: 49),
     .packedEnum({ $0.repeatedNestedEnum }, fieldNumber: 51),
     .packedEnum({ $0.repeatedForeignEnum }, fieldNumber: 52),
     .repeatedString({ $0.repeatedStringPiece }, fieldNumber: 54),
     .repeatedString({ $0.repeatedCord }, fieldNumber: 55),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 56),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 57),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 58),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 59),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 60),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 61),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 62),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 63),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 64),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 65),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 66),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 67),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 68),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 69),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0.mapStringBytes }, fieldNumber: 70),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage>.self, { $0.mapStringNestedMessage }, fieldNumber: 71),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_ForeignMessage>.self, { $0.mapStringForeignMessage }, fieldNumber: 72),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum>.self, { $0.mapStringNestedEnum }, fieldNumber: 73),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_ForeignEnum>.self, { $0.mapStringForeignEnum }, fieldNumber: 74),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapInt32Int32 }, fieldNumber: 56),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapInt64Int64 }, fieldNumber: 57),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapUint32Uint32 }, fieldNumber: 58),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapUint64Uint64 }, fieldNumber: 59),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSint32Sint32 }, fieldNumber: 60),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSint64Sint64 }, fieldNumber: 61),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapFixed32Fixed32 }, fieldNumber: 62),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapFixed64Fixed64 }, fieldNumber: 63),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSfixed32Sfixed32 }, fieldNumber: 64),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSfixed64Sfixed64 }, fieldNumber: 65),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapInt32Float }, fieldNumber: 66),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapInt32Double }, fieldNumber: 67),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapBoolBool }, fieldNumber: 68),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapStringString }, fieldNumber: 69),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapStringBytes }, fieldNumber: 70),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage>.self, { $0._storage._mapStringNestedMessage }, fieldNumber: 71),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_ForeignMessage>.self, { $0._storage._mapStringForeignMessage }, fieldNumber: 72),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum>.self, { $0._storage._mapStringNestedEnum }, fieldNumber: 73),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,ProtobufTestMessages_Proto3_ForeignEnum>.self, { $0._storage._mapStringForeignEnum }, fieldNumber: 74),
     .packedInt32({ $0.packedInt32 }, fieldNumber: 75),
     .packedInt64({ $0.packedInt64 }, fieldNumber: 76),
     .packedUInt32({ $0.packedUint32 }, fieldNumber: 77),
@@ -1975,38 +1975,38 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message,
         return _oneOfField_oneofNullValue
       }
     },
-    .singularMessage({ $0.optionalBoolWrapper }, fieldNumber: 201, isUnset: { $0._storage._optionalBoolWrapper == nil }),
-    .singularMessage({ $0.optionalInt32Wrapper }, fieldNumber: 202, isUnset: { $0._storage._optionalInt32Wrapper == nil }),
-    .singularMessage({ $0.optionalInt64Wrapper }, fieldNumber: 203, isUnset: { $0._storage._optionalInt64Wrapper == nil }),
-    .singularMessage({ $0.optionalUint32Wrapper }, fieldNumber: 204, isUnset: { $0._storage._optionalUint32Wrapper == nil }),
-    .singularMessage({ $0.optionalUint64Wrapper }, fieldNumber: 205, isUnset: { $0._storage._optionalUint64Wrapper == nil }),
-    .singularMessage({ $0.optionalFloatWrapper }, fieldNumber: 206, isUnset: { $0._storage._optionalFloatWrapper == nil }),
-    .singularMessage({ $0.optionalDoubleWrapper }, fieldNumber: 207, isUnset: { $0._storage._optionalDoubleWrapper == nil }),
-    .singularMessage({ $0.optionalStringWrapper }, fieldNumber: 208, isUnset: { $0._storage._optionalStringWrapper == nil }),
-    .singularMessage({ $0.optionalBytesWrapper }, fieldNumber: 209, isUnset: { $0._storage._optionalBytesWrapper == nil }),
-    .repeatedMessage({ $0.repeatedBoolWrapper }, fieldNumber: 211),
-    .repeatedMessage({ $0.repeatedInt32Wrapper }, fieldNumber: 212),
-    .repeatedMessage({ $0.repeatedInt64Wrapper }, fieldNumber: 213),
-    .repeatedMessage({ $0.repeatedUint32Wrapper }, fieldNumber: 214),
-    .repeatedMessage({ $0.repeatedUint64Wrapper }, fieldNumber: 215),
-    .repeatedMessage({ $0.repeatedFloatWrapper }, fieldNumber: 216),
-    .repeatedMessage({ $0.repeatedDoubleWrapper }, fieldNumber: 217),
-    .repeatedMessage({ $0.repeatedStringWrapper }, fieldNumber: 218),
-    .repeatedMessage({ $0.repeatedBytesWrapper }, fieldNumber: 219),
-    .singularMessage({ $0.optionalDuration }, fieldNumber: 301, isUnset: { $0._storage._optionalDuration == nil }),
-    .singularMessage({ $0.optionalTimestamp }, fieldNumber: 302, isUnset: { $0._storage._optionalTimestamp == nil }),
-    .singularMessage({ $0.optionalFieldMask }, fieldNumber: 303, isUnset: { $0._storage._optionalFieldMask == nil }),
-    .singularMessage({ $0.optionalStruct }, fieldNumber: 304, isUnset: { $0._storage._optionalStruct == nil }),
-    .singularMessage({ $0.optionalAny }, fieldNumber: 305, isUnset: { $0._storage._optionalAny == nil }),
-    .singularMessage({ $0.optionalValue }, fieldNumber: 306, isUnset: { $0._storage._optionalValue == nil }),
+    .singularMessage({ $0._storage._optionalBoolWrapper }, fieldNumber: 201),
+    .singularMessage({ $0._storage._optionalInt32Wrapper }, fieldNumber: 202),
+    .singularMessage({ $0._storage._optionalInt64Wrapper }, fieldNumber: 203),
+    .singularMessage({ $0._storage._optionalUint32Wrapper }, fieldNumber: 204),
+    .singularMessage({ $0._storage._optionalUint64Wrapper }, fieldNumber: 205),
+    .singularMessage({ $0._storage._optionalFloatWrapper }, fieldNumber: 206),
+    .singularMessage({ $0._storage._optionalDoubleWrapper }, fieldNumber: 207),
+    .singularMessage({ $0._storage._optionalStringWrapper }, fieldNumber: 208),
+    .singularMessage({ $0._storage._optionalBytesWrapper }, fieldNumber: 209),
+    .repeatedMessage({ $0._storage._repeatedBoolWrapper }, fieldNumber: 211),
+    .repeatedMessage({ $0._storage._repeatedInt32Wrapper }, fieldNumber: 212),
+    .repeatedMessage({ $0._storage._repeatedInt64Wrapper }, fieldNumber: 213),
+    .repeatedMessage({ $0._storage._repeatedUint32Wrapper }, fieldNumber: 214),
+    .repeatedMessage({ $0._storage._repeatedUint64Wrapper }, fieldNumber: 215),
+    .repeatedMessage({ $0._storage._repeatedFloatWrapper }, fieldNumber: 216),
+    .repeatedMessage({ $0._storage._repeatedDoubleWrapper }, fieldNumber: 217),
+    .repeatedMessage({ $0._storage._repeatedStringWrapper }, fieldNumber: 218),
+    .repeatedMessage({ $0._storage._repeatedBytesWrapper }, fieldNumber: 219),
+    .singularMessage({ $0._storage._optionalDuration }, fieldNumber: 301),
+    .singularMessage({ $0._storage._optionalTimestamp }, fieldNumber: 302),
+    .singularMessage({ $0._storage._optionalFieldMask }, fieldNumber: 303),
+    .singularMessage({ $0._storage._optionalStruct }, fieldNumber: 304),
+    .singularMessage({ $0._storage._optionalAny }, fieldNumber: 305),
+    .singularMessage({ $0._storage._optionalValue }, fieldNumber: 306),
     .singularEnum({ $0.optionalNullValue }, fieldNumber: 307, defaultValue: .nullValue),
-    .repeatedMessage({ $0.repeatedDuration }, fieldNumber: 311),
-    .repeatedMessage({ $0.repeatedTimestamp }, fieldNumber: 312),
-    .repeatedMessage({ $0.repeatedFieldmask }, fieldNumber: 313),
-    .repeatedMessage({ $0.repeatedAny }, fieldNumber: 315),
-    .repeatedMessage({ $0.repeatedValue }, fieldNumber: 316),
-    .repeatedMessage({ $0.repeatedListValue }, fieldNumber: 317),
-    .repeatedMessage({ $0.repeatedStruct }, fieldNumber: 324),
+    .repeatedMessage({ $0._storage._repeatedDuration }, fieldNumber: 311),
+    .repeatedMessage({ $0._storage._repeatedTimestamp }, fieldNumber: 312),
+    .repeatedMessage({ $0._storage._repeatedFieldmask }, fieldNumber: 313),
+    .repeatedMessage({ $0._storage._repeatedAny }, fieldNumber: 315),
+    .repeatedMessage({ $0._storage._repeatedValue }, fieldNumber: 316),
+    .repeatedMessage({ $0._storage._repeatedListValue }, fieldNumber: 317),
+    .repeatedMessage({ $0._storage._repeatedStruct }, fieldNumber: 324),
     .singularInt32({ $0.fieldname1 }, fieldNumber: 401),
     .singularInt32({ $0.fieldName2 }, fieldNumber: 402),
     .singularInt32({ $0.fieldName3 }, fieldNumber: 403),
@@ -2027,7 +2027,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message,
     .singularInt32({ $0.fieldName18__ }, fieldNumber: 418),
   ]
   private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
-  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112)
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
   private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 115, isUnset: { _ in false })
@@ -2257,7 +2257,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: SwiftPro
 
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.a }, fieldNumber: 1),
-    .singularMessage({ $0.corecursive }, fieldNumber: 2, isUnset: { $0._storage._corecursive == nil }),
+    .singularMessage({ $0._storage._corecursive }, fieldNumber: 2),
   ]
 
 
diff --git a/Sources/SwiftProtobuf/Field.swift b/Sources/SwiftProtobuf/Field.swift
index 47ddb88ad..287076041 100644
--- a/Sources/SwiftProtobuf/Field.swift
+++ b/Sources/SwiftProtobuf/Field.swift
@@ -30,6 +30,7 @@ public struct Field<M: Message> {
     public static func singularFloat(_ getValue: @escaping (M) -> Float, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularFloatField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularDouble(_ getValue: @escaping (M) -> Double, fieldNumber: Int, defaultValue: Double = 0) -> Self {
         Self(field: SingularDoubleField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -37,6 +38,7 @@ public struct Field<M: Message> {
     public static func singularDouble(_ getValue: @escaping (M) -> Double, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularDoubleField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularInt32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, defaultValue: Int32 = 0) -> Self {
         Self(field: SingularInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -44,6 +46,7 @@ public struct Field<M: Message> {
     public static func singularInt32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularInt64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, defaultValue: Int64 = 0) -> Self {
         Self(field: SingularInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -51,6 +54,7 @@ public struct Field<M: Message> {
     public static func singularInt64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularUInt32(_ getValue: @escaping (M) -> UInt32, fieldNumber: Int, defaultValue: UInt32 = 0) -> Self {
         Self(field: SingularUInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -58,6 +62,7 @@ public struct Field<M: Message> {
     public static func singularUInt32(_ getValue: @escaping (M) -> UInt32, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularUInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularUInt64(_ getValue: @escaping (M) -> UInt64, fieldNumber: Int, defaultValue: UInt64 = 0) -> Self {
         Self(field: SingularUInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -65,6 +70,7 @@ public struct Field<M: Message> {
     public static func singularUInt64(_ getValue: @escaping (M) -> UInt64, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularUInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularSInt32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, defaultValue: Int32 = 0) -> Self {
         Self(field: SingularSInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -72,6 +78,7 @@ public struct Field<M: Message> {
     public static func singularSInt32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularSInt32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularSInt64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, defaultValue: Int64 = 0) -> Self {
         Self(field: SingularSInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -79,6 +86,7 @@ public struct Field<M: Message> {
     public static func singularSInt64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularSInt64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularFixed32(_ getValue: @escaping (M) -> UInt32, fieldNumber: Int, defaultValue: UInt32 = 0) -> Self {
         Self(field: SingularFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -86,6 +94,7 @@ public struct Field<M: Message> {
     public static func singularFixed32(_ getValue: @escaping (M) -> UInt32, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularFixed64(_ getValue: @escaping (M) -> UInt64, fieldNumber: Int, defaultValue: UInt64 = 0) -> Self {
         Self(field: SingularFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -93,6 +102,7 @@ public struct Field<M: Message> {
     public static func singularFixed64(_ getValue: @escaping (M) -> UInt64, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularSFixed32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, defaultValue: Int32 = 0) -> Self {
         Self(field: SingularSFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -100,6 +110,7 @@ public struct Field<M: Message> {
     public static func singularSFixed32(_ getValue: @escaping (M) -> Int32, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularSFixed32Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularSFixed64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, defaultValue: Int64 = 0) -> Self {
         Self(field: SingularSFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -107,6 +118,7 @@ public struct Field<M: Message> {
     public static func singularSFixed64(_ getValue: @escaping (M) -> Int64, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularSFixed64Field(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularBool(_ getValue: @escaping (M) -> Bool, fieldNumber: Int, defaultValue: Bool = false) -> Self {
         Self(field: SingularBoolField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -114,6 +126,7 @@ public struct Field<M: Message> {
     public static func singularBool(_ getValue: @escaping (M) -> Bool, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularBoolField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularString(_ getValue: @escaping (M) -> String, fieldNumber: Int, defaultValue: String = "") -> Self {
         Self(field: SingularStringField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -121,6 +134,7 @@ public struct Field<M: Message> {
     public static func singularString(_ getValue: @escaping (M) -> String, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularStringField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+
     public static func singularBytes(_ getValue: @escaping (M) -> Data, fieldNumber: Int, defaultValue: Data = Data()) -> Self {
         Self(field: SingularBytesField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == defaultValue })
     }
@@ -248,13 +262,20 @@ public struct Field<M: Message> {
     public static func singularEnum<E: Enum>(_ getValue: @escaping (M) -> E, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
         Self(field: SingularEnumField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
     }
+  
+  public static func singularMessage<MessageType: Message>(_ getValue: @escaping (M) -> MessageType, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+    Self(field: SingularMessageField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+  }
+  public static func singularGroup<MessageType: Message>(_ getValue: @escaping (M) -> MessageType, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
+    Self(field: SingularGroupField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+  }
 
-    public static func singularMessage<MessageType: Message>(_ getValue: @escaping (M) -> MessageType, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
-        Self(field: SingularMessageField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    public static func singularMessage<MessageType: Message>(_ getValue: @escaping (M) -> MessageType?, fieldNumber: Int) -> Self {
+        Self(field: SingularMessageField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == nil })
     }
     
-    public static func singularGroup<MessageType: Message>(_ getValue: @escaping (M) -> MessageType, fieldNumber: Int, isUnset: @escaping (M) -> Bool) -> Self {
-        Self(field: SingularGroupField(getValue: getValue), fieldNumber: fieldNumber, isDefault: isUnset)
+    public static func singularGroup<MessageType: Message>(_ getValue: @escaping (M) -> MessageType?, fieldNumber: Int) -> Self {
+        Self(field: SingularGroupField(getValue: getValue), fieldNumber: fieldNumber, isDefault: { getValue($0) == nil })
     }
 
     public static func repeatedEnum<E: Enum>(_ getValue: @escaping (M) -> [E], fieldNumber: Int) -> Self {
@@ -677,18 +698,18 @@ fileprivate struct PackedBoolField<M: Message>: FieldItem {
 }
 
 fileprivate struct SingularMessageField<M: Message, F: Message>: FieldItem {
-    let getValue: (M) -> F
+    let getValue: (M) -> F?
     
     func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
-        try visitor.visitSingularMessageField(value: getValue(message), fieldNumber: fieldNumber)
+        try visitor.visitSingularMessageField(value: getValue(message) ?? .init(), fieldNumber: fieldNumber)
     }
 }
 
 fileprivate struct SingularGroupField<M: Message, F: Message>: FieldItem {
-    let getValue: (M) -> F
+    let getValue: (M) -> F?
     
     func traverse<V: Visitor>(message: M, fieldNumber: Int, visitor: inout V) throws {
-        try visitor.visitSingularGroupField(value: getValue(message), fieldNumber: fieldNumber)
+        try visitor.visitSingularGroupField(value: getValue(message) ?? .init(), fieldNumber: fieldNumber)
     }
 }
 
diff --git a/Sources/SwiftProtobuf/Message.swift b/Sources/SwiftProtobuf/Message.swift
index af5031d6a..3bcccd93e 100644
--- a/Sources/SwiftProtobuf/Message.swift
+++ b/Sources/SwiftProtobuf/Message.swift
@@ -110,9 +110,6 @@ public protocol Message: _CommonMessageConformances {
   /// normal `Equatable`. `Equatable` is provided with specific generated
   /// types.
   func isEqualTo(message: any Message) -> Bool
-    
-  /// Provides `Field` information for this `Message` type used to provide a default implementation of `traverse`
-  static var _fields: [Field<Self>] { get }
 }
 
 #if DEBUG
@@ -132,14 +129,6 @@ extension Message {
     return true
   }
 
-  /// Default traverse implementation
-  public func traverse<V: Visitor>(visitor: inout V) throws {
-    for field in Self._fields {
-      try field.traverse(message: self, visitor: &visitor)
-    }
-    try unknownFields.traverse(visitor: &visitor)
-  }
-
   /// A hash based on the message's full contents.
   public func hash(into hasher: inout Hasher) {
     var visitor = HashVisitor(hasher)
@@ -197,6 +186,9 @@ public protocol _MessageImplementationBase: Message, Hashable {
 
   // Legacy function; no longer used, but left to maintain source compatibility.
   func _protobuf_generated_isEqualTo(other: Self) -> Bool
+    
+  /// Provides `Field` information for this `Message` type used to provide a default implementation of `traverse`
+  static var _fields: [Field<Self>] { get }
 }
 
 extension _MessageImplementationBase {
@@ -206,6 +198,14 @@ extension _MessageImplementationBase {
     }
     return self == other
   }
+  
+  /// Default traverse implementation
+  public func traverse<V: Visitor>(visitor: inout V) throws {
+    for field in Self._fields {
+      try field.traverse(message: self, visitor: &visitor)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
 
   // Legacy default implementation that is used by old generated code, current
   // versions of the plugin/generator provide this directly, but this is here
diff --git a/Sources/SwiftProtobuf/api.pb.swift b/Sources/SwiftProtobuf/api.pb.swift
index cd686b29c..5a1eb95ee 100644
--- a/Sources/SwiftProtobuf/api.pb.swift
+++ b/Sources/SwiftProtobuf/api.pb.swift
@@ -284,7 +284,7 @@ extension Google_Protobuf_Api: Message, _MessageImplementationBase, _ProtoNamePr
     .repeatedMessage({ $0.methods }, fieldNumber: 2),
     .repeatedMessage({ $0.options }, fieldNumber: 3),
     .singularString({ $0.version }, fieldNumber: 4),
-    .singularMessage({ $0.sourceContext }, fieldNumber: 5, isUnset: { $0._sourceContext == nil }),
+    .singularMessage({ $0._sourceContext }, fieldNumber: 5),
     .repeatedMessage({ $0.mixins }, fieldNumber: 6),
     .singularEnum({ $0.syntax }, fieldNumber: 7, defaultValue: .proto2),
   ]
diff --git a/Sources/SwiftProtobuf/descriptor.pb.swift b/Sources/SwiftProtobuf/descriptor.pb.swift
index 926adb1d3..69a8b376d 100644
--- a/Sources/SwiftProtobuf/descriptor.pb.swift
+++ b/Sources/SwiftProtobuf/descriptor.pb.swift
@@ -3037,8 +3037,8 @@ extension Google_Protobuf_FileDescriptorProto: Message, _MessageImplementationBa
     .repeatedMessage({ $0.enumType }, fieldNumber: 5),
     .repeatedMessage({ $0.service }, fieldNumber: 6),
     .repeatedMessage({ $0.`extension` }, fieldNumber: 7),
-    .singularMessage({ $0.options }, fieldNumber: 8, isUnset: { $0._options == nil }),
-    .singularMessage({ $0.sourceCodeInfo }, fieldNumber: 9, isUnset: { $0._sourceCodeInfo == nil }),
+    .singularMessage({ $0._options }, fieldNumber: 8),
+    .singularMessage({ $0._sourceCodeInfo }, fieldNumber: 9),
     .repeatedInt32({ $0.publicDependency }, fieldNumber: 10),
     .repeatedInt32({ $0.weakDependency }, fieldNumber: 11),
     .singularString({ $0.syntax }, fieldNumber: 12, isUnset: { $0._syntax == nil }),
@@ -3156,14 +3156,14 @@ extension Google_Protobuf_DescriptorProto: Message, _MessageImplementationBase,
 
   public static let _fields: [Field<Self>] = [
     .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._storage._name == nil }),
-    .repeatedMessage({ $0.field }, fieldNumber: 2),
-    .repeatedMessage({ $0.nestedType }, fieldNumber: 3),
-    .repeatedMessage({ $0.enumType }, fieldNumber: 4),
-    .repeatedMessage({ $0.extensionRange }, fieldNumber: 5),
-    .repeatedMessage({ $0.`extension` }, fieldNumber: 6),
-    .singularMessage({ $0.options }, fieldNumber: 7, isUnset: { $0._storage._options == nil }),
-    .repeatedMessage({ $0.oneofDecl }, fieldNumber: 8),
-    .repeatedMessage({ $0.reservedRange }, fieldNumber: 9),
+    .repeatedMessage({ $0._storage._field }, fieldNumber: 2),
+    .repeatedMessage({ $0._storage._nestedType }, fieldNumber: 3),
+    .repeatedMessage({ $0._storage._enumType }, fieldNumber: 4),
+    .repeatedMessage({ $0._storage._extensionRange }, fieldNumber: 5),
+    .repeatedMessage({ $0._storage._extension }, fieldNumber: 6),
+    .singularMessage({ $0._storage._options }, fieldNumber: 7),
+    .repeatedMessage({ $0._storage._oneofDecl }, fieldNumber: 8),
+    .repeatedMessage({ $0._storage._reservedRange }, fieldNumber: 9),
     .repeatedString({ $0.reservedName }, fieldNumber: 10),
   ]
 
@@ -3222,7 +3222,7 @@ extension Google_Protobuf_DescriptorProto.ExtensionRange: Message, _MessageImple
   public static let _fields: [Field<Self>] = [
     .singularInt32({ $0.start }, fieldNumber: 1, isUnset: { $0._start == nil }),
     .singularInt32({ $0.end }, fieldNumber: 2, isUnset: { $0._end == nil }),
-    .singularMessage({ $0.options }, fieldNumber: 3, isUnset: { $0._options == nil }),
+    .singularMessage({ $0._options }, fieldNumber: 3),
   ]
 
 
@@ -3305,7 +3305,7 @@ extension Google_Protobuf_ExtensionRangeOptions: Message, _MessageImplementation
   public static let _fields: [Field<Self>] = [
     .repeatedMessage({ $0.declaration }, fieldNumber: 2),
     .singularEnum({ $0.verification }, fieldNumber: 3, isUnset: { $0._verification == nil }),
-    .singularMessage({ $0.features }, fieldNumber: 50, isUnset: { $0._features == nil }),
+    .singularMessage({ $0._features }, fieldNumber: 50),
     .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
   ]
@@ -3426,7 +3426,7 @@ extension Google_Protobuf_FieldDescriptorProto: Message, _MessageImplementationB
     .singularEnum({ $0.type }, fieldNumber: 5, isUnset: { $0._type == nil }),
     .singularString({ $0.typeName }, fieldNumber: 6, isUnset: { $0._typeName == nil }),
     .singularString({ $0.defaultValue }, fieldNumber: 7, isUnset: { $0._defaultValue == nil }),
-    .singularMessage({ $0.options }, fieldNumber: 8, isUnset: { $0._options == nil }),
+    .singularMessage({ $0._options }, fieldNumber: 8),
     .singularInt32({ $0.oneofIndex }, fieldNumber: 9, isUnset: { $0._oneofIndex == nil }),
     .singularString({ $0.jsonName }, fieldNumber: 10, isUnset: { $0._jsonName == nil }),
     .singularBool({ $0.proto3Optional }, fieldNumber: 17, isUnset: { $0._proto3Optional == nil }),
@@ -3508,7 +3508,7 @@ extension Google_Protobuf_OneofDescriptorProto: Message, _MessageImplementationB
 
   public static let _fields: [Field<Self>] = [
     .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
-    .singularMessage({ $0.options }, fieldNumber: 2, isUnset: { $0._options == nil }),
+    .singularMessage({ $0._options }, fieldNumber: 2),
   ]
 
 
@@ -3555,7 +3555,7 @@ extension Google_Protobuf_EnumDescriptorProto: Message, _MessageImplementationBa
   public static let _fields: [Field<Self>] = [
     .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
     .repeatedMessage({ $0.value }, fieldNumber: 2),
-    .singularMessage({ $0.options }, fieldNumber: 3, isUnset: { $0._options == nil }),
+    .singularMessage({ $0._options }, fieldNumber: 3),
     .repeatedMessage({ $0.reservedRange }, fieldNumber: 4),
     .repeatedString({ $0.reservedName }, fieldNumber: 5),
   ]
@@ -3636,7 +3636,7 @@ extension Google_Protobuf_EnumValueDescriptorProto: Message, _MessageImplementat
   public static let _fields: [Field<Self>] = [
     .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
     .singularInt32({ $0.number }, fieldNumber: 2, isUnset: { $0._number == nil }),
-    .singularMessage({ $0.options }, fieldNumber: 3, isUnset: { $0._options == nil }),
+    .singularMessage({ $0._options }, fieldNumber: 3),
   ]
 
 
@@ -3680,7 +3680,7 @@ extension Google_Protobuf_ServiceDescriptorProto: Message, _MessageImplementatio
   public static let _fields: [Field<Self>] = [
     .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
     .repeatedMessage({ $0.method }, fieldNumber: 2),
-    .singularMessage({ $0.options }, fieldNumber: 3, isUnset: { $0._options == nil }),
+    .singularMessage({ $0._options }, fieldNumber: 3),
   ]
 
 
@@ -3730,7 +3730,7 @@ extension Google_Protobuf_MethodDescriptorProto: Message, _MessageImplementation
     .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
     .singularString({ $0.inputType }, fieldNumber: 2, isUnset: { $0._inputType == nil }),
     .singularString({ $0.outputType }, fieldNumber: 3, isUnset: { $0._outputType == nil }),
-    .singularMessage({ $0.options }, fieldNumber: 4, isUnset: { $0._options == nil }),
+    .singularMessage({ $0._options }, fieldNumber: 4),
     .singularBool({ $0.clientStreaming }, fieldNumber: 5, isUnset: { $0._clientStreaming == nil }),
     .singularBool({ $0.serverStreaming }, fieldNumber: 6, isUnset: { $0._serverStreaming == nil }),
   ]
@@ -3904,8 +3904,8 @@ extension Google_Protobuf_FileOptions: Message, _MessageImplementationBase, _Pro
     .singularBool({ $0.phpGenericServices }, fieldNumber: 42, isUnset: { $0._storage._phpGenericServices == nil }),
     .singularString({ $0.phpMetadataNamespace }, fieldNumber: 44, isUnset: { $0._storage._phpMetadataNamespace == nil }),
     .singularString({ $0.rubyPackage }, fieldNumber: 45, isUnset: { $0._storage._rubyPackage == nil }),
-    .singularMessage({ $0.features }, fieldNumber: 50, isUnset: { $0._storage._features == nil }),
-    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .singularMessage({ $0._storage._features }, fieldNumber: 50),
+    .repeatedMessage({ $0._storage._uninterpretedOption }, fieldNumber: 999),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
   ]
 
@@ -4000,7 +4000,7 @@ extension Google_Protobuf_MessageOptions: Message, _MessageImplementationBase, _
     .singularBool({ $0.deprecated }, fieldNumber: 3, isUnset: { $0._deprecated == nil }),
     .singularBool({ $0.mapEntry }, fieldNumber: 7, isUnset: { $0._mapEntry == nil }),
     .singularBool({ $0.deprecatedLegacyJsonFieldConflicts }, fieldNumber: 11, isUnset: { $0._deprecatedLegacyJsonFieldConflicts == nil }),
-    .singularMessage({ $0.features }, fieldNumber: 12, isUnset: { $0._features == nil }),
+    .singularMessage({ $0._features }, fieldNumber: 12),
     .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
   ]
@@ -4130,9 +4130,9 @@ extension Google_Protobuf_FieldOptions: Message, _MessageImplementationBase, _Pr
     .singularBool({ $0.debugRedact }, fieldNumber: 16, isUnset: { $0._storage._debugRedact == nil }),
     .singularEnum({ $0.retention }, fieldNumber: 17, isUnset: { $0._storage._retention == nil }),
     .repeatedEnum({ $0.targets }, fieldNumber: 19),
-    .repeatedMessage({ $0.editionDefaults }, fieldNumber: 20),
-    .singularMessage({ $0.features }, fieldNumber: 21, isUnset: { $0._storage._features == nil }),
-    .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
+    .repeatedMessage({ $0._storage._editionDefaults }, fieldNumber: 20),
+    .singularMessage({ $0._storage._features }, fieldNumber: 21),
+    .repeatedMessage({ $0._storage._uninterpretedOption }, fieldNumber: 999),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
   ]
 
@@ -4268,7 +4268,7 @@ extension Google_Protobuf_OneofOptions: Message, _MessageImplementationBase, _Pr
   }
 
   public static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.features }, fieldNumber: 1, isUnset: { $0._features == nil }),
+    .singularMessage({ $0._features }, fieldNumber: 1),
     .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
   ]
@@ -4322,7 +4322,7 @@ extension Google_Protobuf_EnumOptions: Message, _MessageImplementationBase, _Pro
     .singularBool({ $0.allowAlias }, fieldNumber: 2, isUnset: { $0._allowAlias == nil }),
     .singularBool({ $0.deprecated }, fieldNumber: 3, isUnset: { $0._deprecated == nil }),
     .singularBool({ $0.deprecatedLegacyJsonFieldConflicts }, fieldNumber: 6, isUnset: { $0._deprecatedLegacyJsonFieldConflicts == nil }),
-    .singularMessage({ $0.features }, fieldNumber: 7, isUnset: { $0._features == nil }),
+    .singularMessage({ $0._features }, fieldNumber: 7),
     .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
   ]
@@ -4375,7 +4375,7 @@ extension Google_Protobuf_EnumValueOptions: Message, _MessageImplementationBase,
 
   public static let _fields: [Field<Self>] = [
     .singularBool({ $0.deprecated }, fieldNumber: 1, isUnset: { $0._deprecated == nil }),
-    .singularMessage({ $0.features }, fieldNumber: 2, isUnset: { $0._features == nil }),
+    .singularMessage({ $0._features }, fieldNumber: 2),
     .singularBool({ $0.debugRedact }, fieldNumber: 3, isUnset: { $0._debugRedact == nil }),
     .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
@@ -4426,7 +4426,7 @@ extension Google_Protobuf_ServiceOptions: Message, _MessageImplementationBase, _
 
   public static let _fields: [Field<Self>] = [
     .singularBool({ $0.deprecated }, fieldNumber: 33, isUnset: { $0._deprecated == nil }),
-    .singularMessage({ $0.features }, fieldNumber: 34, isUnset: { $0._features == nil }),
+    .singularMessage({ $0._features }, fieldNumber: 34),
     .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
   ]
@@ -4478,7 +4478,7 @@ extension Google_Protobuf_MethodOptions: Message, _MessageImplementationBase, _P
   public static let _fields: [Field<Self>] = [
     .singularBool({ $0.deprecated }, fieldNumber: 33, isUnset: { $0._deprecated == nil }),
     .singularEnum({ $0.idempotencyLevel }, fieldNumber: 34, isUnset: { $0._idempotencyLevel == nil }),
-    .singularMessage({ $0.features }, fieldNumber: 35, isUnset: { $0._features == nil }),
+    .singularMessage({ $0._features }, fieldNumber: 35),
     .repeatedMessage({ $0.uninterpretedOption }, fieldNumber: 999),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
   ]
@@ -4779,7 +4779,7 @@ extension Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault: Message,
   }
 
   public static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.features }, fieldNumber: 2, isUnset: { $0._features == nil }),
+    .singularMessage({ $0._features }, fieldNumber: 2),
     .singularEnum({ $0.edition }, fieldNumber: 3, isUnset: { $0._edition == nil }),
   ]
 
diff --git a/Sources/SwiftProtobuf/struct.pb.swift b/Sources/SwiftProtobuf/struct.pb.swift
index 6717e9590..e21bf22b8 100644
--- a/Sources/SwiftProtobuf/struct.pb.swift
+++ b/Sources/SwiftProtobuf/struct.pb.swift
@@ -354,8 +354,8 @@ extension Google_Protobuf_Value: Message, _MessageImplementationBase, _ProtoName
   private static let _oneOfField_numberValue: Field<Self> = .singularDouble({ $0.numberValue }, fieldNumber: 2, isUnset: { _ in false })
   private static let _oneOfField_stringValue: Field<Self> = .singularString({ $0.stringValue }, fieldNumber: 3, isUnset: { _ in false })
   private static let _oneOfField_boolValue: Field<Self> = .singularBool({ $0.boolValue }, fieldNumber: 4, isUnset: { _ in false })
-  private static let _oneOfField_structValue: Field<Self> = .singularMessage({ $0.structValue }, fieldNumber: 5, isUnset: { _ in false })
-  private static let _oneOfField_listValue: Field<Self> = .singularMessage({ $0.listValue }, fieldNumber: 6, isUnset: { _ in false })
+  private static let _oneOfField_structValue: Field<Self> = .singularMessage({ $0.structValue }, fieldNumber: 5)
+  private static let _oneOfField_listValue: Field<Self> = .singularMessage({ $0.listValue }, fieldNumber: 6)
 
 
   public static func ==(lhs: Google_Protobuf_Value, rhs: Google_Protobuf_Value) -> Bool {
diff --git a/Sources/SwiftProtobuf/type.pb.swift b/Sources/SwiftProtobuf/type.pb.swift
index 060185c67..351c45179 100644
--- a/Sources/SwiftProtobuf/type.pb.swift
+++ b/Sources/SwiftProtobuf/type.pb.swift
@@ -508,7 +508,7 @@ extension Google_Protobuf_Type: Message, _MessageImplementationBase, _ProtoNameP
     .repeatedMessage({ $0.fields }, fieldNumber: 2),
     .repeatedString({ $0.oneofs }, fieldNumber: 3),
     .repeatedMessage({ $0.options }, fieldNumber: 4),
-    .singularMessage({ $0.sourceContext }, fieldNumber: 5, isUnset: { $0._sourceContext == nil }),
+    .singularMessage({ $0._sourceContext }, fieldNumber: 5),
     .singularEnum({ $0.syntax }, fieldNumber: 6, defaultValue: .proto2),
     .singularString({ $0.edition }, fieldNumber: 7),
   ]
@@ -658,7 +658,7 @@ extension Google_Protobuf_Enum: Message, _MessageImplementationBase, _ProtoNameP
     .singularString({ $0.name }, fieldNumber: 1),
     .repeatedMessage({ $0.enumvalue }, fieldNumber: 2),
     .repeatedMessage({ $0.options }, fieldNumber: 3),
-    .singularMessage({ $0.sourceContext }, fieldNumber: 4, isUnset: { $0._sourceContext == nil }),
+    .singularMessage({ $0._sourceContext }, fieldNumber: 4),
     .singularEnum({ $0.syntax }, fieldNumber: 5, defaultValue: .proto2),
     .singularString({ $0.edition }, fieldNumber: 6),
   ]
@@ -736,7 +736,7 @@ extension Google_Protobuf_Option: Message, _MessageImplementationBase, _ProtoNam
 
   public static let _fields: [Field<Self>] = [
     .singularString({ $0.name }, fieldNumber: 1),
-    .singularMessage({ $0.value }, fieldNumber: 2, isUnset: { $0._value == nil }),
+    .singularMessage({ $0._value }, fieldNumber: 2),
   ]
 
 
diff --git a/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift b/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift
index 9eeff24d3..d1f70b5b2 100644
--- a/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift
+++ b/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift
@@ -446,7 +446,7 @@ extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message,
   public static let _fields: [Field<Self>] = [
     .repeatedString({ $0.fileToGenerate }, fieldNumber: 1),
     .singularString({ $0.parameter }, fieldNumber: 2, isUnset: { $0._parameter == nil }),
-    .singularMessage({ $0.compilerVersion }, fieldNumber: 3, isUnset: { $0._compilerVersion == nil }),
+    .singularMessage({ $0._compilerVersion }, fieldNumber: 3),
     .repeatedMessage({ $0.protoFile }, fieldNumber: 15),
     .repeatedMessage({ $0.sourceFileDescriptors }, fieldNumber: 17),
   ]
@@ -545,7 +545,7 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse.File: SwiftProtobuf.Mes
     .singularString({ $0.name }, fieldNumber: 1, isUnset: { $0._name == nil }),
     .singularString({ $0.insertionPoint }, fieldNumber: 2, isUnset: { $0._insertionPoint == nil }),
     .singularString({ $0.content }, fieldNumber: 15, isUnset: { $0._content == nil }),
-    .singularMessage({ $0.generatedCodeInfo }, fieldNumber: 16, isUnset: { $0._generatedCodeInfo == nil }),
+    .singularMessage({ $0._generatedCodeInfo }, fieldNumber: 16),
   ]
 
 
diff --git a/Sources/protoc-gen-swift/MessageFieldGenerator.swift b/Sources/protoc-gen-swift/MessageFieldGenerator.swift
index 1242f5ca1..dc0756cd7 100644
--- a/Sources/protoc-gen-swift/MessageFieldGenerator.swift
+++ b/Sources/protoc-gen-swift/MessageFieldGenerator.swift
@@ -237,8 +237,10 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator {
           traitsArg = ""
       }
       
+      let getterName = isGroupOrMessage ? storedPropertyWithoutSelf : swiftName
+      
       let suffix: String
-      if isRepeated {
+      if isRepeated || isGroupOrMessage {
         suffix = ""
       } else if hasFieldPresence {
         suffix = ", isUnset: { $0.\(storedPropertyWithoutSelf) == nil }"
@@ -247,6 +249,6 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator {
       } else {
         suffix = ""
       }
-      p.print(".\(factoryMethod)(\(traitsArg){ $0.\(swiftName) }, fieldNumber: \(number)\(suffix)),")
+      p.print(".\(factoryMethod)(\(traitsArg){ $0.\(getterName) }, fieldNumber: \(number)\(suffix)),")
     }
 }
diff --git a/Sources/protoc-gen-swift/OneofGenerator.swift b/Sources/protoc-gen-swift/OneofGenerator.swift
index 7402bf919..f44d33b6e 100644
--- a/Sources/protoc-gen-swift/OneofGenerator.swift
+++ b/Sources/protoc-gen-swift/OneofGenerator.swift
@@ -388,7 +388,8 @@ class OneofGenerator {
     
     func generateFieldNodeStaticLet(printer p: inout CodePrinter) {
         for field in fieldsSortedByNumber {
-            p.print("private static let _oneOfField_\(field.swiftName): Field<Self> = .singular\(field.protoGenericType)({ $0.\(field.swiftName) }, fieldNumber: \(field.number), isUnset: { _ in false })")
+            let suffix = field.isGroupOrMessage ? "" :  ", isUnset: { _ in false }"
+            p.print("private static let _oneOfField_\(field.swiftName): Field<Self> = .singular\(field.protoGenericType)({ $0.\(field.swiftName) }, fieldNumber: \(field.number)\(suffix))")
         }
         
     }
diff --git a/Tests/SwiftProtobufTests/any_test.pb.swift b/Tests/SwiftProtobufTests/any_test.pb.swift
index c1665b3e9..f1be5a15e 100644
--- a/Tests/SwiftProtobufTests/any_test.pb.swift
+++ b/Tests/SwiftProtobufTests/any_test.pb.swift
@@ -107,7 +107,7 @@ extension SwiftProtoTesting_TestAny: SwiftProtobuf.Message, SwiftProtobuf._Messa
 
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.int32Value }, fieldNumber: 1),
-    .singularMessage({ $0.anyValue }, fieldNumber: 2, isUnset: { $0._anyValue == nil }),
+    .singularMessage({ $0._anyValue }, fieldNumber: 2),
     .repeatedMessage({ $0.repeatedAnyValue }, fieldNumber: 3),
     .singularString({ $0.text }, fieldNumber: 4),
   ]
diff --git a/Tests/SwiftProtobufTests/fuzz_testing.pb.swift b/Tests/SwiftProtobufTests/fuzz_testing.pb.swift
index ce13fce25..e1f423fb3 100644
--- a/Tests/SwiftProtobufTests/fuzz_testing.pb.swift
+++ b/Tests/SwiftProtobufTests/fuzz_testing.pb.swift
@@ -3869,8 +3869,8 @@ extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._
     .singularString({ $0.singularString }, fieldNumber: 14, isUnset: { $0._storage._singularString == nil }),
     .singularBytes({ $0.singularBytes }, fieldNumber: 15, isUnset: { $0._storage._singularBytes == nil }),
     .singularEnum({ $0.singularEnum }, fieldNumber: 16, isUnset: { $0._storage._singularEnum == nil }),
-    .singularGroup({ $0.singularGroup }, fieldNumber: 17, isUnset: { $0._storage._singularGroup == nil }),
-    .singularMessage({ $0.singularMessage }, fieldNumber: 19, isUnset: { $0._storage._singularMessage == nil }),
+    .singularGroup({ $0._storage._singularGroup }, fieldNumber: 17),
+    .singularMessage({ $0._storage._singularMessage }, fieldNumber: 19),
     .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
     .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
     .repeatedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
@@ -3887,8 +3887,8 @@ extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._
     .repeatedString({ $0.repeatedString }, fieldNumber: 44),
     .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
     .repeatedEnum({ $0.repeatedEnum }, fieldNumber: 46),
-    .repeatedGroup({ $0.repeatedGroup }, fieldNumber: 47),
-    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 49),
+    .repeatedGroup({ $0._storage._repeatedGroup }, fieldNumber: 47),
+    .repeatedMessage({ $0._storage._repeatedMessage }, fieldNumber: 49),
     .oneOf({ $0.o }) {
       switch $0 {
       case .oneofInt32:
@@ -3943,213 +3943,213 @@ extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._
     .packedDouble({ $0.repeatedPackedDouble }, fieldNumber: 92),
     .packedBool({ $0.repeatedPackedBool }, fieldNumber: 93),
     .packedEnum({ $0.repeatedPackedEnum }, fieldNumber: 94),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 100),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt32Int64 }, fieldNumber: 101),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapInt32Uint32 }, fieldNumber: 102),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapInt32Uint64 }, fieldNumber: 103),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapInt32Sint32 }, fieldNumber: 104),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapInt32Sint64 }, fieldNumber: 105),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapInt32Fixed32 }, fieldNumber: 106),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapInt32Fixed64 }, fieldNumber: 107),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapInt32Sfixed32 }, fieldNumber: 108),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapInt32Sfixed64 }, fieldNumber: 109),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 110),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 111),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapInt32Bool }, fieldNumber: 112),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapInt32String }, fieldNumber: 113),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt32Bytes }, fieldNumber: 114),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapInt32AnEnum }, fieldNumber: 115),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapInt32Message }, fieldNumber: 116),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt64Int32 }, fieldNumber: 117),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 118),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapInt64Uint32 }, fieldNumber: 119),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapInt64Uint64 }, fieldNumber: 120),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapInt64Sint32 }, fieldNumber: 121),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapInt64Sint64 }, fieldNumber: 122),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapInt64Fixed32 }, fieldNumber: 123),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapInt64Fixed64 }, fieldNumber: 124),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapInt64Sfixed32 }, fieldNumber: 125),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapInt64Sfixed64 }, fieldNumber: 126),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt64Float }, fieldNumber: 127),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt64Double }, fieldNumber: 128),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapInt64Bool }, fieldNumber: 129),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapInt64String }, fieldNumber: 130),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt64Bytes }, fieldNumber: 131),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapInt64AnEnum }, fieldNumber: 132),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapInt64Message }, fieldNumber: 133),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapUint32Int32 }, fieldNumber: 134),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapUint32Int64 }, fieldNumber: 135),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 136),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint32Uint64 }, fieldNumber: 137),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapUint32Sint32 }, fieldNumber: 138),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapUint32Sint64 }, fieldNumber: 139),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapUint32Fixed32 }, fieldNumber: 140),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapUint32Fixed64 }, fieldNumber: 141),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapUint32Sfixed32 }, fieldNumber: 142),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapUint32Sfixed64 }, fieldNumber: 143),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapUint32Float }, fieldNumber: 144),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapUint32Double }, fieldNumber: 145),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapUint32Bool }, fieldNumber: 146),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapUint32String }, fieldNumber: 147),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapUint32Bytes }, fieldNumber: 148),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapUint32AnEnum }, fieldNumber: 149),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapUint32Message }, fieldNumber: 150),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapUint64Int32 }, fieldNumber: 151),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapUint64Int64 }, fieldNumber: 152),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint64Uint32 }, fieldNumber: 153),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 154),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapUint64Sint32 }, fieldNumber: 155),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapUint64Sint64 }, fieldNumber: 156),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapUint64Fixed32 }, fieldNumber: 157),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapUint64Fixed64 }, fieldNumber: 158),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapUint64Sfixed32 }, fieldNumber: 159),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapUint64Sfixed64 }, fieldNumber: 160),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapUint64Float }, fieldNumber: 161),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapUint64Double }, fieldNumber: 162),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapUint64Bool }, fieldNumber: 163),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapUint64String }, fieldNumber: 164),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapUint64Bytes }, fieldNumber: 165),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapUint64AnEnum }, fieldNumber: 166),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapUint64Message }, fieldNumber: 167),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSint32Int32 }, fieldNumber: 168),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSint32Int64 }, fieldNumber: 169),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSint32Uint32 }, fieldNumber: 170),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSint32Uint64 }, fieldNumber: 171),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 172),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint32Sint64 }, fieldNumber: 173),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSint32Fixed32 }, fieldNumber: 174),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSint32Fixed64 }, fieldNumber: 175),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSint32Sfixed32 }, fieldNumber: 176),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSint32Sfixed64 }, fieldNumber: 177),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSint32Float }, fieldNumber: 178),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSint32Double }, fieldNumber: 179),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBool>.self, { $0.mapSint32Bool }, fieldNumber: 180),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufString>.self, { $0.mapSint32String }, fieldNumber: 181),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSint32Bytes }, fieldNumber: 182),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSint32AnEnum }, fieldNumber: 183),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSint32Message }, fieldNumber: 184),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSint64Int32 }, fieldNumber: 185),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSint64Int64 }, fieldNumber: 186),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSint64Uint32 }, fieldNumber: 187),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSint64Uint64 }, fieldNumber: 188),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint64Sint32 }, fieldNumber: 189),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 190),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSint64Fixed32 }, fieldNumber: 191),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSint64Fixed64 }, fieldNumber: 192),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSint64Sfixed32 }, fieldNumber: 193),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSint64Sfixed64 }, fieldNumber: 194),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSint64Float }, fieldNumber: 195),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSint64Double }, fieldNumber: 196),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBool>.self, { $0.mapSint64Bool }, fieldNumber: 197),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufString>.self, { $0.mapSint64String }, fieldNumber: 198),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSint64Bytes }, fieldNumber: 199),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSint64AnEnum }, fieldNumber: 200),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSint64Message }, fieldNumber: 201),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapFixed32Int32 }, fieldNumber: 202),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapFixed32Int64 }, fieldNumber: 203),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapFixed32Uint32 }, fieldNumber: 204),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapFixed32Uint64 }, fieldNumber: 205),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapFixed32Sint32 }, fieldNumber: 206),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapFixed32Sint64 }, fieldNumber: 207),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 208),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed32Fixed64 }, fieldNumber: 209),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapFixed32Sfixed32 }, fieldNumber: 210),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapFixed32Sfixed64 }, fieldNumber: 211),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapFixed32Float }, fieldNumber: 212),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapFixed32Double }, fieldNumber: 213),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBool>.self, { $0.mapFixed32Bool }, fieldNumber: 214),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufString>.self, { $0.mapFixed32String }, fieldNumber: 215),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapFixed32Bytes }, fieldNumber: 216),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapFixed32AnEnum }, fieldNumber: 217),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapFixed32Message }, fieldNumber: 218),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapFixed64Int32 }, fieldNumber: 219),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapFixed64Int64 }, fieldNumber: 220),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapFixed64Uint32 }, fieldNumber: 221),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapFixed64Uint64 }, fieldNumber: 222),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapFixed64Sint32 }, fieldNumber: 223),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapFixed64Sint64 }, fieldNumber: 224),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed64Fixed32 }, fieldNumber: 225),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 226),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapFixed64Sfixed32 }, fieldNumber: 227),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapFixed64Sfixed64 }, fieldNumber: 228),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapFixed64Float }, fieldNumber: 229),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapFixed64Double }, fieldNumber: 230),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBool>.self, { $0.mapFixed64Bool }, fieldNumber: 231),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufString>.self, { $0.mapFixed64String }, fieldNumber: 232),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapFixed64Bytes }, fieldNumber: 233),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapFixed64AnEnum }, fieldNumber: 234),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapFixed64Message }, fieldNumber: 235),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSfixed32Int32 }, fieldNumber: 236),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSfixed32Int64 }, fieldNumber: 237),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSfixed32Uint32 }, fieldNumber: 238),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSfixed32Uint64 }, fieldNumber: 239),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSfixed32Sint32 }, fieldNumber: 240),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSfixed32Sint64 }, fieldNumber: 241),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSfixed32Fixed32 }, fieldNumber: 242),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSfixed32Fixed64 }, fieldNumber: 243),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 244),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed32Sfixed64 }, fieldNumber: 245),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSfixed32Float }, fieldNumber: 246),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSfixed32Double }, fieldNumber: 247),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBool>.self, { $0.mapSfixed32Bool }, fieldNumber: 248),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufString>.self, { $0.mapSfixed32String }, fieldNumber: 249),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSfixed32Bytes }, fieldNumber: 250),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSfixed32AnEnum }, fieldNumber: 251),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSfixed32Message }, fieldNumber: 252),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0.mapSfixed64Int32 }, fieldNumber: 253),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapSfixed64Int64 }, fieldNumber: 254),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapSfixed64Uint32 }, fieldNumber: 255),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapSfixed64Uint64 }, fieldNumber: 256),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSfixed64Sint32 }, fieldNumber: 257),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSfixed64Sint64 }, fieldNumber: 258),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapSfixed64Fixed32 }, fieldNumber: 259),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapSfixed64Fixed64 }, fieldNumber: 260),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed64Sfixed32 }, fieldNumber: 261),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 262),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0.mapSfixed64Float }, fieldNumber: 263),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0.mapSfixed64Double }, fieldNumber: 264),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBool>.self, { $0.mapSfixed64Bool }, fieldNumber: 265),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufString>.self, { $0.mapSfixed64String }, fieldNumber: 266),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0.mapSfixed64Bytes }, fieldNumber: 267),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapSfixed64AnEnum }, fieldNumber: 268),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapSfixed64Message }, fieldNumber: 269),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt32>.self, { $0.mapBoolInt32 }, fieldNumber: 270),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt64>.self, { $0.mapBoolInt64 }, fieldNumber: 271),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapBoolUint32 }, fieldNumber: 272),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapBoolUint64 }, fieldNumber: 273),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapBoolSint32 }, fieldNumber: 274),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapBoolSint64 }, fieldNumber: 275),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapBoolFixed32 }, fieldNumber: 276),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapBoolFixed64 }, fieldNumber: 277),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapBoolSfixed32 }, fieldNumber: 278),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapBoolSfixed64 }, fieldNumber: 279),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFloat>.self, { $0.mapBoolFloat }, fieldNumber: 280),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufDouble>.self, { $0.mapBoolDouble }, fieldNumber: 281),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 282),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufString>.self, { $0.mapBoolString }, fieldNumber: 283),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBytes>.self, { $0.mapBoolBytes }, fieldNumber: 284),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0.mapBoolAnEnum }, fieldNumber: 285),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_Message>.self, { $0.mapBoolMessage }, fieldNumber: 286),
-    .singularMessage({ $0.wktAny }, fieldNumber: 500, isUnset: { $0._storage._wktAny == nil }),
-    .singularMessage({ $0.wktApi }, fieldNumber: 501, isUnset: { $0._storage._wktApi == nil }),
-    .singularMessage({ $0.wktDuration }, fieldNumber: 502, isUnset: { $0._storage._wktDuration == nil }),
-    .singularMessage({ $0.wktEmpty }, fieldNumber: 503, isUnset: { $0._storage._wktEmpty == nil }),
-    .singularMessage({ $0.wktFieldMask }, fieldNumber: 504, isUnset: { $0._storage._wktFieldMask == nil }),
-    .singularMessage({ $0.wktSourceContext }, fieldNumber: 505, isUnset: { $0._storage._wktSourceContext == nil }),
-    .singularMessage({ $0.wktStruct }, fieldNumber: 506, isUnset: { $0._storage._wktStruct == nil }),
-    .singularMessage({ $0.wktTimestamp }, fieldNumber: 507, isUnset: { $0._storage._wktTimestamp == nil }),
-    .singularMessage({ $0.wktType }, fieldNumber: 508, isUnset: { $0._storage._wktType == nil }),
-    .singularMessage({ $0.wktDoubleValue }, fieldNumber: 509, isUnset: { $0._storage._wktDoubleValue == nil }),
-    .singularMessage({ $0.wktFloatValue }, fieldNumber: 510, isUnset: { $0._storage._wktFloatValue == nil }),
-    .singularMessage({ $0.wktInt64Value }, fieldNumber: 511, isUnset: { $0._storage._wktInt64Value == nil }),
-    .singularMessage({ $0.wktUint64Value }, fieldNumber: 512, isUnset: { $0._storage._wktUint64Value == nil }),
-    .singularMessage({ $0.wktInt32Value }, fieldNumber: 513, isUnset: { $0._storage._wktInt32Value == nil }),
-    .singularMessage({ $0.wktUint32Value }, fieldNumber: 514, isUnset: { $0._storage._wktUint32Value == nil }),
-    .singularMessage({ $0.wktBoolValue }, fieldNumber: 515, isUnset: { $0._storage._wktBoolValue == nil }),
-    .singularMessage({ $0.wktStringValue }, fieldNumber: 516, isUnset: { $0._storage._wktStringValue == nil }),
-    .singularMessage({ $0.wktBytesValue }, fieldNumber: 517, isUnset: { $0._storage._wktBytesValue == nil }),
-    .singularMessage({ $0.singularMessageSet }, fieldNumber: 600, isUnset: { $0._storage._singularMessageSet == nil }),
-    .repeatedMessage({ $0.repeatedMessageSet }, fieldNumber: 601),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapInt32Int32 }, fieldNumber: 100),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapInt32Int64 }, fieldNumber: 101),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapInt32Uint32 }, fieldNumber: 102),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapInt32Uint64 }, fieldNumber: 103),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapInt32Sint32 }, fieldNumber: 104),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapInt32Sint64 }, fieldNumber: 105),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapInt32Fixed32 }, fieldNumber: 106),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapInt32Fixed64 }, fieldNumber: 107),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapInt32Sfixed32 }, fieldNumber: 108),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapInt32Sfixed64 }, fieldNumber: 109),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapInt32Float }, fieldNumber: 110),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapInt32Double }, fieldNumber: 111),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapInt32Bool }, fieldNumber: 112),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapInt32String }, fieldNumber: 113),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapInt32Bytes }, fieldNumber: 114),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapInt32AnEnum }, fieldNumber: 115),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapInt32Message }, fieldNumber: 116),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapInt64Int32 }, fieldNumber: 117),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapInt64Int64 }, fieldNumber: 118),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapInt64Uint32 }, fieldNumber: 119),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapInt64Uint64 }, fieldNumber: 120),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapInt64Sint32 }, fieldNumber: 121),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapInt64Sint64 }, fieldNumber: 122),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapInt64Fixed32 }, fieldNumber: 123),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapInt64Fixed64 }, fieldNumber: 124),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapInt64Sfixed32 }, fieldNumber: 125),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapInt64Sfixed64 }, fieldNumber: 126),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapInt64Float }, fieldNumber: 127),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapInt64Double }, fieldNumber: 128),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapInt64Bool }, fieldNumber: 129),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapInt64String }, fieldNumber: 130),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapInt64Bytes }, fieldNumber: 131),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapInt64AnEnum }, fieldNumber: 132),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapInt64Message }, fieldNumber: 133),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapUint32Int32 }, fieldNumber: 134),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapUint32Int64 }, fieldNumber: 135),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapUint32Uint32 }, fieldNumber: 136),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapUint32Uint64 }, fieldNumber: 137),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapUint32Sint32 }, fieldNumber: 138),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapUint32Sint64 }, fieldNumber: 139),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapUint32Fixed32 }, fieldNumber: 140),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapUint32Fixed64 }, fieldNumber: 141),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapUint32Sfixed32 }, fieldNumber: 142),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapUint32Sfixed64 }, fieldNumber: 143),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapUint32Float }, fieldNumber: 144),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapUint32Double }, fieldNumber: 145),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapUint32Bool }, fieldNumber: 146),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapUint32String }, fieldNumber: 147),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapUint32Bytes }, fieldNumber: 148),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapUint32AnEnum }, fieldNumber: 149),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapUint32Message }, fieldNumber: 150),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapUint64Int32 }, fieldNumber: 151),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapUint64Int64 }, fieldNumber: 152),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapUint64Uint32 }, fieldNumber: 153),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapUint64Uint64 }, fieldNumber: 154),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapUint64Sint32 }, fieldNumber: 155),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapUint64Sint64 }, fieldNumber: 156),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapUint64Fixed32 }, fieldNumber: 157),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapUint64Fixed64 }, fieldNumber: 158),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapUint64Sfixed32 }, fieldNumber: 159),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapUint64Sfixed64 }, fieldNumber: 160),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapUint64Float }, fieldNumber: 161),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapUint64Double }, fieldNumber: 162),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapUint64Bool }, fieldNumber: 163),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapUint64String }, fieldNumber: 164),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapUint64Bytes }, fieldNumber: 165),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapUint64AnEnum }, fieldNumber: 166),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufUInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapUint64Message }, fieldNumber: 167),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapSint32Int32 }, fieldNumber: 168),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapSint32Int64 }, fieldNumber: 169),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapSint32Uint32 }, fieldNumber: 170),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapSint32Uint64 }, fieldNumber: 171),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSint32Sint32 }, fieldNumber: 172),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSint32Sint64 }, fieldNumber: 173),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapSint32Fixed32 }, fieldNumber: 174),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapSint32Fixed64 }, fieldNumber: 175),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSint32Sfixed32 }, fieldNumber: 176),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSint32Sfixed64 }, fieldNumber: 177),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapSint32Float }, fieldNumber: 178),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapSint32Double }, fieldNumber: 179),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapSint32Bool }, fieldNumber: 180),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapSint32String }, fieldNumber: 181),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapSint32Bytes }, fieldNumber: 182),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapSint32AnEnum }, fieldNumber: 183),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt32,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapSint32Message }, fieldNumber: 184),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapSint64Int32 }, fieldNumber: 185),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapSint64Int64 }, fieldNumber: 186),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapSint64Uint32 }, fieldNumber: 187),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapSint64Uint64 }, fieldNumber: 188),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSint64Sint32 }, fieldNumber: 189),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSint64Sint64 }, fieldNumber: 190),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapSint64Fixed32 }, fieldNumber: 191),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapSint64Fixed64 }, fieldNumber: 192),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSint64Sfixed32 }, fieldNumber: 193),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSint64Sfixed64 }, fieldNumber: 194),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapSint64Float }, fieldNumber: 195),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapSint64Double }, fieldNumber: 196),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapSint64Bool }, fieldNumber: 197),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapSint64String }, fieldNumber: 198),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapSint64Bytes }, fieldNumber: 199),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapSint64AnEnum }, fieldNumber: 200),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSInt64,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapSint64Message }, fieldNumber: 201),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapFixed32Int32 }, fieldNumber: 202),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapFixed32Int64 }, fieldNumber: 203),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapFixed32Uint32 }, fieldNumber: 204),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapFixed32Uint64 }, fieldNumber: 205),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapFixed32Sint32 }, fieldNumber: 206),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapFixed32Sint64 }, fieldNumber: 207),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapFixed32Fixed32 }, fieldNumber: 208),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapFixed32Fixed64 }, fieldNumber: 209),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapFixed32Sfixed32 }, fieldNumber: 210),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapFixed32Sfixed64 }, fieldNumber: 211),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapFixed32Float }, fieldNumber: 212),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapFixed32Double }, fieldNumber: 213),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapFixed32Bool }, fieldNumber: 214),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapFixed32String }, fieldNumber: 215),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapFixed32Bytes }, fieldNumber: 216),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapFixed32AnEnum }, fieldNumber: 217),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapFixed32Message }, fieldNumber: 218),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapFixed64Int32 }, fieldNumber: 219),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapFixed64Int64 }, fieldNumber: 220),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapFixed64Uint32 }, fieldNumber: 221),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapFixed64Uint64 }, fieldNumber: 222),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapFixed64Sint32 }, fieldNumber: 223),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapFixed64Sint64 }, fieldNumber: 224),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapFixed64Fixed32 }, fieldNumber: 225),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapFixed64Fixed64 }, fieldNumber: 226),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapFixed64Sfixed32 }, fieldNumber: 227),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapFixed64Sfixed64 }, fieldNumber: 228),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapFixed64Float }, fieldNumber: 229),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapFixed64Double }, fieldNumber: 230),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapFixed64Bool }, fieldNumber: 231),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapFixed64String }, fieldNumber: 232),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapFixed64Bytes }, fieldNumber: 233),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapFixed64AnEnum }, fieldNumber: 234),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapFixed64Message }, fieldNumber: 235),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapSfixed32Int32 }, fieldNumber: 236),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapSfixed32Int64 }, fieldNumber: 237),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapSfixed32Uint32 }, fieldNumber: 238),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapSfixed32Uint64 }, fieldNumber: 239),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSfixed32Sint32 }, fieldNumber: 240),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSfixed32Sint64 }, fieldNumber: 241),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapSfixed32Fixed32 }, fieldNumber: 242),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapSfixed32Fixed64 }, fieldNumber: 243),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSfixed32Sfixed32 }, fieldNumber: 244),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSfixed32Sfixed64 }, fieldNumber: 245),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapSfixed32Float }, fieldNumber: 246),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapSfixed32Double }, fieldNumber: 247),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapSfixed32Bool }, fieldNumber: 248),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapSfixed32String }, fieldNumber: 249),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapSfixed32Bytes }, fieldNumber: 250),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapSfixed32AnEnum }, fieldNumber: 251),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapSfixed32Message }, fieldNumber: 252),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapSfixed64Int32 }, fieldNumber: 253),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapSfixed64Int64 }, fieldNumber: 254),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapSfixed64Uint32 }, fieldNumber: 255),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapSfixed64Uint64 }, fieldNumber: 256),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSfixed64Sint32 }, fieldNumber: 257),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSfixed64Sint64 }, fieldNumber: 258),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapSfixed64Fixed32 }, fieldNumber: 259),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapSfixed64Fixed64 }, fieldNumber: 260),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSfixed64Sfixed32 }, fieldNumber: 261),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSfixed64Sfixed64 }, fieldNumber: 262),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapSfixed64Float }, fieldNumber: 263),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapSfixed64Double }, fieldNumber: 264),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapSfixed64Bool }, fieldNumber: 265),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapSfixed64String }, fieldNumber: 266),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapSfixed64Bytes }, fieldNumber: 267),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapSfixed64AnEnum }, fieldNumber: 268),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapSfixed64Message }, fieldNumber: 269),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapBoolInt32 }, fieldNumber: 270),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapBoolInt64 }, fieldNumber: 271),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapBoolUint32 }, fieldNumber: 272),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapBoolUint64 }, fieldNumber: 273),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapBoolSint32 }, fieldNumber: 274),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapBoolSint64 }, fieldNumber: 275),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapBoolFixed32 }, fieldNumber: 276),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapBoolFixed64 }, fieldNumber: 277),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapBoolSfixed32 }, fieldNumber: 278),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapBoolSfixed64 }, fieldNumber: 279),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapBoolFloat }, fieldNumber: 280),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapBoolDouble }, fieldNumber: 281),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapBoolBool }, fieldNumber: 282),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapBoolString }, fieldNumber: 283),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapBoolBytes }, fieldNumber: 284),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_AnEnum>.self, { $0._storage._mapBoolAnEnum }, fieldNumber: 285),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufBool,SwiftProtoTesting_Fuzz_Message>.self, { $0._storage._mapBoolMessage }, fieldNumber: 286),
+    .singularMessage({ $0._storage._wktAny }, fieldNumber: 500),
+    .singularMessage({ $0._storage._wktApi }, fieldNumber: 501),
+    .singularMessage({ $0._storage._wktDuration }, fieldNumber: 502),
+    .singularMessage({ $0._storage._wktEmpty }, fieldNumber: 503),
+    .singularMessage({ $0._storage._wktFieldMask }, fieldNumber: 504),
+    .singularMessage({ $0._storage._wktSourceContext }, fieldNumber: 505),
+    .singularMessage({ $0._storage._wktStruct }, fieldNumber: 506),
+    .singularMessage({ $0._storage._wktTimestamp }, fieldNumber: 507),
+    .singularMessage({ $0._storage._wktType }, fieldNumber: 508),
+    .singularMessage({ $0._storage._wktDoubleValue }, fieldNumber: 509),
+    .singularMessage({ $0._storage._wktFloatValue }, fieldNumber: 510),
+    .singularMessage({ $0._storage._wktInt64Value }, fieldNumber: 511),
+    .singularMessage({ $0._storage._wktUint64Value }, fieldNumber: 512),
+    .singularMessage({ $0._storage._wktInt32Value }, fieldNumber: 513),
+    .singularMessage({ $0._storage._wktUint32Value }, fieldNumber: 514),
+    .singularMessage({ $0._storage._wktBoolValue }, fieldNumber: 515),
+    .singularMessage({ $0._storage._wktStringValue }, fieldNumber: 516),
+    .singularMessage({ $0._storage._wktBytesValue }, fieldNumber: 517),
+    .singularMessage({ $0._storage._singularMessageSet }, fieldNumber: 600),
+    .repeatedMessage({ $0._storage._repeatedMessageSet }, fieldNumber: 601),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 2001),
   ]
   private static let _oneOfField_oneofInt32: Field<Self> = .singularInt32({ $0.oneofInt32 }, fieldNumber: 61, isUnset: { _ in false })
@@ -4168,8 +4168,8 @@ extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 74, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 75, isUnset: { _ in false })
   private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 76, isUnset: { _ in false })
-  private static let _oneOfField_oneofGroup: Field<Self> = .singularGroup({ $0.oneofGroup }, fieldNumber: 77, isUnset: { _ in false })
-  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 79, isUnset: { _ in false })
+  private static let _oneOfField_oneofGroup: Field<Self> = .singularGroup({ $0.oneofGroup }, fieldNumber: 77)
+  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 79)
 
 
   static func ==(lhs: SwiftProtoTesting_Fuzz_Message, rhs: SwiftProtoTesting_Fuzz_Message) -> Bool {
diff --git a/Tests/SwiftProtobufTests/map_unittest.pb.swift b/Tests/SwiftProtobufTests/map_unittest.pb.swift
index f2e259dbf..bdd9bce78 100644
--- a/Tests/SwiftProtobufTests/map_unittest.pb.swift
+++ b/Tests/SwiftProtobufTests/map_unittest.pb.swift
@@ -346,25 +346,25 @@ extension SwiftProtoTesting_TestMap: SwiftProtobuf.Message, SwiftProtobuf._Messa
   }
 
   static let _fields: [Field<Self>] = [
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 1),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 2),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 3),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 4),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 5),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 6),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 7),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 8),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 9),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 10),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 11),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 12),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 13),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 14),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt32Bytes }, fieldNumber: 15),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_MapEnum>.self, { $0.mapInt32Enum }, fieldNumber: 16),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_ForeignMessage>.self, { $0.mapInt32ForeignMessage }, fieldNumber: 17),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_ForeignMessage>.self, { $0.mapStringForeignMessage }, fieldNumber: 18),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_TestAllTypes>.self, { $0.mapInt32AllTypes }, fieldNumber: 19),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapInt32Int32 }, fieldNumber: 1),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapInt64Int64 }, fieldNumber: 2),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapUint32Uint32 }, fieldNumber: 3),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapUint64Uint64 }, fieldNumber: 4),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSint32Sint32 }, fieldNumber: 5),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSint64Sint64 }, fieldNumber: 6),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapFixed32Fixed32 }, fieldNumber: 7),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapFixed64Fixed64 }, fieldNumber: 8),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSfixed32Sfixed32 }, fieldNumber: 9),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSfixed64Sfixed64 }, fieldNumber: 10),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapInt32Float }, fieldNumber: 11),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapInt32Double }, fieldNumber: 12),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapBoolBool }, fieldNumber: 13),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapStringString }, fieldNumber: 14),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapInt32Bytes }, fieldNumber: 15),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_MapEnum>.self, { $0._storage._mapInt32Enum }, fieldNumber: 16),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_ForeignMessage>.self, { $0._storage._mapInt32ForeignMessage }, fieldNumber: 17),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_ForeignMessage>.self, { $0._storage._mapStringForeignMessage }, fieldNumber: 18),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_TestAllTypes>.self, { $0._storage._mapInt32AllTypes }, fieldNumber: 19),
   ]
 
 
diff --git a/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift b/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift
index 75520cdd6..d5c63d1d9 100644
--- a/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift
+++ b/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift
@@ -1370,7 +1370,7 @@ extension SwiftProtoTesting_Test3_TestAllTypesProto3: SwiftProtobuf.Message, Swi
     .singularBool({ $0.optionalBool }, fieldNumber: 13),
     .singularString({ $0.optionalString }, fieldNumber: 14),
     .singularBytes({ $0.optionalBytes }, fieldNumber: 15),
-    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
+    .singularMessage({ $0._storage._optionalNestedMessage }, fieldNumber: 18),
     .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, defaultValue: .foo),
     .packedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
     .packedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
@@ -1387,25 +1387,25 @@ extension SwiftProtoTesting_Test3_TestAllTypesProto3: SwiftProtobuf.Message, Swi
     .packedBool({ $0.repeatedBool }, fieldNumber: 43),
     .repeatedString({ $0.repeatedString }, fieldNumber: 44),
     .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
-    .repeatedMessage({ $0.repeatedNestedMessage }, fieldNumber: 48),
+    .repeatedMessage({ $0._storage._repeatedNestedMessage }, fieldNumber: 48),
     .packedEnum({ $0.repeatedNestedEnum }, fieldNumber: 51),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 56),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 57),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 58),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 59),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 60),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 61),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 62),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 63),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 64),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 65),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 66),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 67),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 68),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 69),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0.mapStringBytes }, fieldNumber: 70),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage>.self, { $0.mapStringNestedMessage }, fieldNumber: 71),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum>.self, { $0.mapStringNestedEnum }, fieldNumber: 73),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapInt32Int32 }, fieldNumber: 56),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapInt64Int64 }, fieldNumber: 57),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapUint32Uint32 }, fieldNumber: 58),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapUint64Uint64 }, fieldNumber: 59),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSint32Sint32 }, fieldNumber: 60),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSint64Sint64 }, fieldNumber: 61),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapFixed32Fixed32 }, fieldNumber: 62),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapFixed64Fixed64 }, fieldNumber: 63),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSfixed32Sfixed32 }, fieldNumber: 64),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSfixed64Sfixed64 }, fieldNumber: 65),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapInt32Float }, fieldNumber: 66),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapInt32Double }, fieldNumber: 67),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapBoolBool }, fieldNumber: 68),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapStringString }, fieldNumber: 69),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapStringBytes }, fieldNumber: 70),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage>.self, { $0._storage._mapStringNestedMessage }, fieldNumber: 71),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum>.self, { $0._storage._mapStringNestedEnum }, fieldNumber: 73),
     .oneOf({ $0.oneofField }) {
       switch $0 {
       case .oneofUint32:
@@ -1430,38 +1430,38 @@ extension SwiftProtoTesting_Test3_TestAllTypesProto3: SwiftProtobuf.Message, Swi
         return _oneOfField_oneofNullValue
       }
     },
-    .singularMessage({ $0.optionalBoolWrapper }, fieldNumber: 201, isUnset: { $0._storage._optionalBoolWrapper == nil }),
-    .singularMessage({ $0.optionalInt32Wrapper }, fieldNumber: 202, isUnset: { $0._storage._optionalInt32Wrapper == nil }),
-    .singularMessage({ $0.optionalInt64Wrapper }, fieldNumber: 203, isUnset: { $0._storage._optionalInt64Wrapper == nil }),
-    .singularMessage({ $0.optionalUint32Wrapper }, fieldNumber: 204, isUnset: { $0._storage._optionalUint32Wrapper == nil }),
-    .singularMessage({ $0.optionalUint64Wrapper }, fieldNumber: 205, isUnset: { $0._storage._optionalUint64Wrapper == nil }),
-    .singularMessage({ $0.optionalFloatWrapper }, fieldNumber: 206, isUnset: { $0._storage._optionalFloatWrapper == nil }),
-    .singularMessage({ $0.optionalDoubleWrapper }, fieldNumber: 207, isUnset: { $0._storage._optionalDoubleWrapper == nil }),
-    .singularMessage({ $0.optionalStringWrapper }, fieldNumber: 208, isUnset: { $0._storage._optionalStringWrapper == nil }),
-    .singularMessage({ $0.optionalBytesWrapper }, fieldNumber: 209, isUnset: { $0._storage._optionalBytesWrapper == nil }),
-    .repeatedMessage({ $0.repeatedBoolWrapper }, fieldNumber: 211),
-    .repeatedMessage({ $0.repeatedInt32Wrapper }, fieldNumber: 212),
-    .repeatedMessage({ $0.repeatedInt64Wrapper }, fieldNumber: 213),
-    .repeatedMessage({ $0.repeatedUint32Wrapper }, fieldNumber: 214),
-    .repeatedMessage({ $0.repeatedUint64Wrapper }, fieldNumber: 215),
-    .repeatedMessage({ $0.repeatedFloatWrapper }, fieldNumber: 216),
-    .repeatedMessage({ $0.repeatedDoubleWrapper }, fieldNumber: 217),
-    .repeatedMessage({ $0.repeatedStringWrapper }, fieldNumber: 218),
-    .repeatedMessage({ $0.repeatedBytesWrapper }, fieldNumber: 219),
-    .singularMessage({ $0.optionalDuration }, fieldNumber: 301, isUnset: { $0._storage._optionalDuration == nil }),
-    .singularMessage({ $0.optionalTimestamp }, fieldNumber: 302, isUnset: { $0._storage._optionalTimestamp == nil }),
-    .singularMessage({ $0.optionalFieldMask }, fieldNumber: 303, isUnset: { $0._storage._optionalFieldMask == nil }),
-    .singularMessage({ $0.optionalStruct }, fieldNumber: 304, isUnset: { $0._storage._optionalStruct == nil }),
-    .singularMessage({ $0.optionalAny }, fieldNumber: 305, isUnset: { $0._storage._optionalAny == nil }),
-    .singularMessage({ $0.optionalValue }, fieldNumber: 306, isUnset: { $0._storage._optionalValue == nil }),
+    .singularMessage({ $0._storage._optionalBoolWrapper }, fieldNumber: 201),
+    .singularMessage({ $0._storage._optionalInt32Wrapper }, fieldNumber: 202),
+    .singularMessage({ $0._storage._optionalInt64Wrapper }, fieldNumber: 203),
+    .singularMessage({ $0._storage._optionalUint32Wrapper }, fieldNumber: 204),
+    .singularMessage({ $0._storage._optionalUint64Wrapper }, fieldNumber: 205),
+    .singularMessage({ $0._storage._optionalFloatWrapper }, fieldNumber: 206),
+    .singularMessage({ $0._storage._optionalDoubleWrapper }, fieldNumber: 207),
+    .singularMessage({ $0._storage._optionalStringWrapper }, fieldNumber: 208),
+    .singularMessage({ $0._storage._optionalBytesWrapper }, fieldNumber: 209),
+    .repeatedMessage({ $0._storage._repeatedBoolWrapper }, fieldNumber: 211),
+    .repeatedMessage({ $0._storage._repeatedInt32Wrapper }, fieldNumber: 212),
+    .repeatedMessage({ $0._storage._repeatedInt64Wrapper }, fieldNumber: 213),
+    .repeatedMessage({ $0._storage._repeatedUint32Wrapper }, fieldNumber: 214),
+    .repeatedMessage({ $0._storage._repeatedUint64Wrapper }, fieldNumber: 215),
+    .repeatedMessage({ $0._storage._repeatedFloatWrapper }, fieldNumber: 216),
+    .repeatedMessage({ $0._storage._repeatedDoubleWrapper }, fieldNumber: 217),
+    .repeatedMessage({ $0._storage._repeatedStringWrapper }, fieldNumber: 218),
+    .repeatedMessage({ $0._storage._repeatedBytesWrapper }, fieldNumber: 219),
+    .singularMessage({ $0._storage._optionalDuration }, fieldNumber: 301),
+    .singularMessage({ $0._storage._optionalTimestamp }, fieldNumber: 302),
+    .singularMessage({ $0._storage._optionalFieldMask }, fieldNumber: 303),
+    .singularMessage({ $0._storage._optionalStruct }, fieldNumber: 304),
+    .singularMessage({ $0._storage._optionalAny }, fieldNumber: 305),
+    .singularMessage({ $0._storage._optionalValue }, fieldNumber: 306),
     .singularEnum({ $0.optionalNullValue }, fieldNumber: 307, defaultValue: .nullValue),
-    .repeatedMessage({ $0.repeatedDuration }, fieldNumber: 311),
-    .repeatedMessage({ $0.repeatedTimestamp }, fieldNumber: 312),
-    .repeatedMessage({ $0.repeatedFieldmask }, fieldNumber: 313),
-    .repeatedMessage({ $0.repeatedAny }, fieldNumber: 315),
-    .repeatedMessage({ $0.repeatedValue }, fieldNumber: 316),
-    .repeatedMessage({ $0.repeatedListValue }, fieldNumber: 317),
-    .repeatedMessage({ $0.repeatedStruct }, fieldNumber: 324),
+    .repeatedMessage({ $0._storage._repeatedDuration }, fieldNumber: 311),
+    .repeatedMessage({ $0._storage._repeatedTimestamp }, fieldNumber: 312),
+    .repeatedMessage({ $0._storage._repeatedFieldmask }, fieldNumber: 313),
+    .repeatedMessage({ $0._storage._repeatedAny }, fieldNumber: 315),
+    .repeatedMessage({ $0._storage._repeatedValue }, fieldNumber: 316),
+    .repeatedMessage({ $0._storage._repeatedListValue }, fieldNumber: 317),
+    .repeatedMessage({ $0._storage._repeatedStruct }, fieldNumber: 324),
     .singularInt32({ $0.fieldname1 }, fieldNumber: 401),
     .singularInt32({ $0.fieldName2 }, fieldNumber: 402),
     .singularInt32({ $0.fieldName3 }, fieldNumber: 403),
@@ -1482,7 +1482,7 @@ extension SwiftProtoTesting_Test3_TestAllTypesProto3: SwiftProtobuf.Message, Swi
     .singularInt32({ $0.fieldName18__ }, fieldNumber: 418),
   ]
   private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
-  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112)
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
   private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 115, isUnset: { _ in false })
@@ -1664,7 +1664,7 @@ extension SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage: SwiftProtobu
 
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.a }, fieldNumber: 1),
-    .singularMessage({ $0.corecursive }, fieldNumber: 2, isUnset: { $0._storage._corecursive == nil }),
+    .singularMessage({ $0._storage._corecursive }, fieldNumber: 2),
   ]
 
 
diff --git a/Tests/SwiftProtobufTests/unittest.pb.swift b/Tests/SwiftProtobufTests/unittest.pb.swift
index fde89aa10..f9ac65b95 100644
--- a/Tests/SwiftProtobufTests/unittest.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest.pb.swift
@@ -4355,18 +4355,18 @@ extension SwiftProtoTesting_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._
     .singularBool({ $0.optionalBool }, fieldNumber: 13, isUnset: { $0._storage._optionalBool == nil }),
     .singularString({ $0.optionalString }, fieldNumber: 14, isUnset: { $0._storage._optionalString == nil }),
     .singularBytes({ $0.optionalBytes }, fieldNumber: 15, isUnset: { $0._storage._optionalBytes == nil }),
-    .singularGroup({ $0.optionalGroup }, fieldNumber: 16, isUnset: { $0._storage._optionalGroup == nil }),
-    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
-    .singularMessage({ $0.optionalForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._optionalForeignMessage == nil }),
-    .singularMessage({ $0.optionalImportMessage }, fieldNumber: 20, isUnset: { $0._storage._optionalImportMessage == nil }),
+    .singularGroup({ $0._storage._optionalGroup }, fieldNumber: 16),
+    .singularMessage({ $0._storage._optionalNestedMessage }, fieldNumber: 18),
+    .singularMessage({ $0._storage._optionalForeignMessage }, fieldNumber: 19),
+    .singularMessage({ $0._storage._optionalImportMessage }, fieldNumber: 20),
     .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, isUnset: { $0._storage._optionalNestedEnum == nil }),
     .singularEnum({ $0.optionalForeignEnum }, fieldNumber: 22, isUnset: { $0._storage._optionalForeignEnum == nil }),
     .singularEnum({ $0.optionalImportEnum }, fieldNumber: 23, isUnset: { $0._storage._optionalImportEnum == nil }),
     .singularString({ $0.optionalStringPiece }, fieldNumber: 24, isUnset: { $0._storage._optionalStringPiece == nil }),
     .singularString({ $0.optionalCord }, fieldNumber: 25, isUnset: { $0._storage._optionalCord == nil }),
-    .singularMessage({ $0.optionalPublicImportMessage }, fieldNumber: 26, isUnset: { $0._storage._optionalPublicImportMessage == nil }),
-    .singularMessage({ $0.optionalLazyMessage }, fieldNumber: 27, isUnset: { $0._storage._optionalLazyMessage == nil }),
-    .singularMessage({ $0.optionalUnverifiedLazyMessage }, fieldNumber: 28, isUnset: { $0._storage._optionalUnverifiedLazyMessage == nil }),
+    .singularMessage({ $0._storage._optionalPublicImportMessage }, fieldNumber: 26),
+    .singularMessage({ $0._storage._optionalLazyMessage }, fieldNumber: 27),
+    .singularMessage({ $0._storage._optionalUnverifiedLazyMessage }, fieldNumber: 28),
     .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
     .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
     .repeatedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
@@ -4382,16 +4382,16 @@ extension SwiftProtoTesting_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._
     .repeatedBool({ $0.repeatedBool }, fieldNumber: 43),
     .repeatedString({ $0.repeatedString }, fieldNumber: 44),
     .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
-    .repeatedGroup({ $0.repeatedGroup }, fieldNumber: 46),
-    .repeatedMessage({ $0.repeatedNestedMessage }, fieldNumber: 48),
-    .repeatedMessage({ $0.repeatedForeignMessage }, fieldNumber: 49),
-    .repeatedMessage({ $0.repeatedImportMessage }, fieldNumber: 50),
+    .repeatedGroup({ $0._storage._repeatedGroup }, fieldNumber: 46),
+    .repeatedMessage({ $0._storage._repeatedNestedMessage }, fieldNumber: 48),
+    .repeatedMessage({ $0._storage._repeatedForeignMessage }, fieldNumber: 49),
+    .repeatedMessage({ $0._storage._repeatedImportMessage }, fieldNumber: 50),
     .repeatedEnum({ $0.repeatedNestedEnum }, fieldNumber: 51),
     .repeatedEnum({ $0.repeatedForeignEnum }, fieldNumber: 52),
     .repeatedEnum({ $0.repeatedImportEnum }, fieldNumber: 53),
     .repeatedString({ $0.repeatedStringPiece }, fieldNumber: 54),
     .repeatedString({ $0.repeatedCord }, fieldNumber: 55),
-    .repeatedMessage({ $0.repeatedLazyMessage }, fieldNumber: 57),
+    .repeatedMessage({ $0._storage._repeatedLazyMessage }, fieldNumber: 57),
     .singularInt32({ $0.defaultInt32 }, fieldNumber: 61, isUnset: { $0._storage._defaultInt32 == nil }),
     .singularInt64({ $0.defaultInt64 }, fieldNumber: 62, isUnset: { $0._storage._defaultInt64 == nil }),
     .singularUInt32({ $0.defaultUint32 }, fieldNumber: 63, isUnset: { $0._storage._defaultUint32 == nil }),
@@ -4426,7 +4426,7 @@ extension SwiftProtoTesting_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._
     },
   ]
   private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
-  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112)
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
 
@@ -4674,11 +4674,11 @@ extension SwiftProtoTesting_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProt
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.child }, fieldNumber: 1, isUnset: { $0._storage._child == nil }),
-    .singularMessage({ $0.payload }, fieldNumber: 2, isUnset: { $0._storage._payload == nil }),
-    .repeatedMessage({ $0.repeatedChild }, fieldNumber: 3),
-    .singularMessage({ $0.lazyChild }, fieldNumber: 4, isUnset: { $0._storage._lazyChild == nil }),
-    .singularMessage({ $0.eagerChild }, fieldNumber: 5, isUnset: { $0._storage._eagerChild == nil }),
+    .singularMessage({ $0._storage._child }, fieldNumber: 1),
+    .singularMessage({ $0._storage._payload }, fieldNumber: 2),
+    .repeatedMessage({ $0._storage._repeatedChild }, fieldNumber: 3),
+    .singularMessage({ $0._storage._lazyChild }, fieldNumber: 4),
+    .singularMessage({ $0._storage._eagerChild }, fieldNumber: 5),
   ]
 
 
@@ -5058,7 +5058,7 @@ extension SwiftProtoTesting_TestRequired: SwiftProtobuf.Message, SwiftProtobuf._
     .singularInt32({ $0.dummy31 }, fieldNumber: 31, isUnset: { $0._storage._dummy31 == nil }),
     .singularInt32({ $0.dummy32 }, fieldNumber: 32, isUnset: { $0._storage._dummy32 == nil }),
     .singularInt32({ $0.c }, fieldNumber: 33, isUnset: { $0._storage._c == nil }),
-    .singularMessage({ $0.optionalForeign }, fieldNumber: 34, isUnset: { $0._storage._optionalForeign == nil }),
+    .singularMessage({ $0._storage._optionalForeign }, fieldNumber: 34),
   ]
 
 
@@ -5141,10 +5141,10 @@ extension SwiftProtoTesting_TestRequiredForeign: SwiftProtobuf.Message, SwiftPro
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.optionalMessage }, fieldNumber: 1, isUnset: { $0._optionalMessage == nil }),
+    .singularMessage({ $0._optionalMessage }, fieldNumber: 1),
     .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 2),
     .singularInt32({ $0.dummy }, fieldNumber: 3, isUnset: { $0._dummy == nil }),
-    .singularMessage({ $0.optionalLazyMessage }, fieldNumber: 4, isUnset: { $0._optionalLazyMessage == nil }),
+    .singularMessage({ $0._optionalLazyMessage }, fieldNumber: 4),
   ]
 
 
@@ -5189,9 +5189,9 @@ extension SwiftProtoTesting_TestRequiredMessage: SwiftProtobuf.Message, SwiftPro
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.optionalMessage }, fieldNumber: 1, isUnset: { $0._optionalMessage == nil }),
+    .singularMessage({ $0._optionalMessage }, fieldNumber: 1),
     .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 2),
-    .singularMessage({ $0.requiredMessage }, fieldNumber: 3, isUnset: { $0._requiredMessage == nil }),
+    .singularMessage({ $0._requiredMessage }, fieldNumber: 3),
   ]
 
 
@@ -5302,7 +5302,7 @@ extension SwiftProtoTesting_TestRecursiveMessage: SwiftProtobuf.Message, SwiftPr
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.a }, fieldNumber: 1, isUnset: { $0._storage._a == nil }),
+    .singularMessage({ $0._storage._a }, fieldNumber: 1),
     .singularInt32({ $0.i }, fieldNumber: 2, isUnset: { $0._storage._i == nil }),
   ]
 
@@ -5360,7 +5360,7 @@ extension SwiftProtoTesting_TestFieldOrderings: SwiftProtobuf.Message, SwiftProt
     .singularString({ $0.myString }, fieldNumber: 11, isUnset: { $0._myString == nil }),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 12, end: 101),
     .singularFloat({ $0.myFloat }, fieldNumber: 101, isUnset: { $0._myFloat == nil }),
-    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 200, isUnset: { $0._optionalNestedMessage == nil }),
+    .singularMessage({ $0._optionalNestedMessage }, fieldNumber: 200),
   ]
 
 
@@ -5703,8 +5703,8 @@ extension SwiftProtoTesting_TestOneof: SwiftProtobuf.Message, SwiftProtobuf._Mes
   ]
   private static let _oneOfField_fooInt: Field<Self> = .singularInt32({ $0.fooInt }, fieldNumber: 1, isUnset: { _ in false })
   private static let _oneOfField_fooString: Field<Self> = .singularString({ $0.fooString }, fieldNumber: 2, isUnset: { _ in false })
-  private static let _oneOfField_fooMessage: Field<Self> = .singularMessage({ $0.fooMessage }, fieldNumber: 3, isUnset: { _ in false })
-  private static let _oneOfField_fooGroup: Field<Self> = .singularGroup({ $0.fooGroup }, fieldNumber: 4, isUnset: { _ in false })
+  private static let _oneOfField_fooMessage: Field<Self> = .singularMessage({ $0.fooMessage }, fieldNumber: 3)
+  private static let _oneOfField_fooGroup: Field<Self> = .singularGroup({ $0.fooGroup }, fieldNumber: 4)
 
 
   static func ==(lhs: SwiftProtoTesting_TestOneof, rhs: SwiftProtoTesting_TestOneof) -> Bool {
@@ -5831,8 +5831,8 @@ extension SwiftProtoTesting_TestRequiredOneof: SwiftProtobuf.Message, SwiftProto
   ]
   private static let _oneOfField_fooInt: Field<Self> = .singularInt32({ $0.fooInt }, fieldNumber: 1, isUnset: { _ in false })
   private static let _oneOfField_fooString: Field<Self> = .singularString({ $0.fooString }, fieldNumber: 2, isUnset: { _ in false })
-  private static let _oneOfField_fooMessage: Field<Self> = .singularMessage({ $0.fooMessage }, fieldNumber: 3, isUnset: { _ in false })
-  private static let _oneOfField_fooLazyMessage: Field<Self> = .singularMessage({ $0.fooLazyMessage }, fieldNumber: 4, isUnset: { _ in false })
+  private static let _oneOfField_fooMessage: Field<Self> = .singularMessage({ $0.fooMessage }, fieldNumber: 3)
+  private static let _oneOfField_fooLazyMessage: Field<Self> = .singularMessage({ $0.fooLazyMessage }, fieldNumber: 4)
 
 
   static func ==(lhs: SwiftProtoTesting_TestRequiredOneof, rhs: SwiftProtoTesting_TestRequiredOneof) -> Bool {
@@ -6105,10 +6105,10 @@ extension SwiftProtoTesting_TestParsingMerge: SwiftProtobuf.Message, SwiftProtob
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.requiredAllTypes }, fieldNumber: 1, isUnset: { $0._requiredAllTypes == nil }),
-    .singularMessage({ $0.optionalAllTypes }, fieldNumber: 2, isUnset: { $0._optionalAllTypes == nil }),
+    .singularMessage({ $0._requiredAllTypes }, fieldNumber: 1),
+    .singularMessage({ $0._optionalAllTypes }, fieldNumber: 2),
     .repeatedMessage({ $0.repeatedAllTypes }, fieldNumber: 3),
-    .singularGroup({ $0.optionalGroup }, fieldNumber: 10, isUnset: { $0._optionalGroup == nil }),
+    .singularGroup({ $0._optionalGroup }, fieldNumber: 10),
     .repeatedGroup({ $0.repeatedGroup }, fieldNumber: 20),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 1000, end: 536870912),
   ]
@@ -6199,7 +6199,7 @@ extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1: Swi
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.field1 }, fieldNumber: 11, isUnset: { $0._field1 == nil }),
+    .singularMessage({ $0._field1 }, fieldNumber: 11),
   ]
 
 
@@ -6229,7 +6229,7 @@ extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2: Swi
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.field1 }, fieldNumber: 21, isUnset: { $0._field1 == nil }),
+    .singularMessage({ $0._field1 }, fieldNumber: 21),
   ]
 
 
@@ -6259,7 +6259,7 @@ extension SwiftProtoTesting_TestParsingMerge.OptionalGroup: SwiftProtobuf.Messag
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.optionalGroupAllTypes }, fieldNumber: 11, isUnset: { $0._optionalGroupAllTypes == nil }),
+    .singularMessage({ $0._optionalGroupAllTypes }, fieldNumber: 11),
   ]
 
 
@@ -6289,7 +6289,7 @@ extension SwiftProtoTesting_TestParsingMerge.RepeatedGroup: SwiftProtobuf.Messag
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.repeatedGroupAllTypes }, fieldNumber: 21, isUnset: { $0._repeatedGroupAllTypes == nil }),
+    .singularMessage({ $0._repeatedGroupAllTypes }, fieldNumber: 21),
   ]
 
 
diff --git a/Tests/SwiftProtobufTests/unittest_mset.pb.swift b/Tests/SwiftProtobufTests/unittest_mset.pb.swift
index a9ad64e32..8cf8a612e 100644
--- a/Tests/SwiftProtobufTests/unittest_mset.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_mset.pb.swift
@@ -288,7 +288,7 @@ extension SwiftProtoTesting_TestMessageSetContainer: SwiftProtobuf.Message, Swif
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.messageSet }, fieldNumber: 1, isUnset: { $0._messageSet == nil }),
+    .singularMessage({ $0._messageSet }, fieldNumber: 1),
   ]
 
 
@@ -328,7 +328,7 @@ extension SwiftProtoTesting_TestMessageSetExtension1: SwiftProtobuf.Message, Swi
 
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.i }, fieldNumber: 15, isUnset: { $0._i == nil }),
-    .singularMessage({ $0.recursive }, fieldNumber: 16, isUnset: { $0._recursive == nil }),
+    .singularMessage({ $0._recursive }, fieldNumber: 16),
     .singularString({ $0.testAliasing }, fieldNumber: 17, isUnset: { $0._testAliasing == nil }),
   ]
 
diff --git a/Tests/SwiftProtobufTests/unittest_proto3.pb.swift b/Tests/SwiftProtobufTests/unittest_proto3.pb.swift
index dbc0a56b1..ea108bb96 100644
--- a/Tests/SwiftProtobufTests/unittest_proto3.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_proto3.pb.swift
@@ -949,16 +949,16 @@ extension SwiftProtoTesting_Proto3_TestAllTypes: SwiftProtobuf.Message, SwiftPro
     .singularBool({ $0.optionalBool }, fieldNumber: 13),
     .singularString({ $0.optionalString }, fieldNumber: 14),
     .singularBytes({ $0.optionalBytes }, fieldNumber: 15),
-    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
-    .singularMessage({ $0.optionalForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._optionalForeignMessage == nil }),
-    .singularMessage({ $0.optionalImportMessage }, fieldNumber: 20, isUnset: { $0._storage._optionalImportMessage == nil }),
+    .singularMessage({ $0._storage._optionalNestedMessage }, fieldNumber: 18),
+    .singularMessage({ $0._storage._optionalForeignMessage }, fieldNumber: 19),
+    .singularMessage({ $0._storage._optionalImportMessage }, fieldNumber: 20),
     .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, defaultValue: .zero),
     .singularEnum({ $0.optionalForeignEnum }, fieldNumber: 22, defaultValue: .foreignZero),
     .singularString({ $0.optionalStringPiece }, fieldNumber: 24),
     .singularString({ $0.optionalCord }, fieldNumber: 25),
-    .singularMessage({ $0.optionalPublicImportMessage }, fieldNumber: 26, isUnset: { $0._storage._optionalPublicImportMessage == nil }),
-    .singularMessage({ $0.optionalLazyMessage }, fieldNumber: 27, isUnset: { $0._storage._optionalLazyMessage == nil }),
-    .singularMessage({ $0.optionalUnverifiedLazyMessage }, fieldNumber: 28, isUnset: { $0._storage._optionalUnverifiedLazyMessage == nil }),
+    .singularMessage({ $0._storage._optionalPublicImportMessage }, fieldNumber: 26),
+    .singularMessage({ $0._storage._optionalLazyMessage }, fieldNumber: 27),
+    .singularMessage({ $0._storage._optionalUnverifiedLazyMessage }, fieldNumber: 28),
     .packedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
     .packedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
     .packedUInt32({ $0.repeatedUint32 }, fieldNumber: 33),
@@ -974,14 +974,14 @@ extension SwiftProtoTesting_Proto3_TestAllTypes: SwiftProtobuf.Message, SwiftPro
     .packedBool({ $0.repeatedBool }, fieldNumber: 43),
     .repeatedString({ $0.repeatedString }, fieldNumber: 44),
     .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
-    .repeatedMessage({ $0.repeatedNestedMessage }, fieldNumber: 48),
-    .repeatedMessage({ $0.repeatedForeignMessage }, fieldNumber: 49),
-    .repeatedMessage({ $0.repeatedImportMessage }, fieldNumber: 50),
+    .repeatedMessage({ $0._storage._repeatedNestedMessage }, fieldNumber: 48),
+    .repeatedMessage({ $0._storage._repeatedForeignMessage }, fieldNumber: 49),
+    .repeatedMessage({ $0._storage._repeatedImportMessage }, fieldNumber: 50),
     .packedEnum({ $0.repeatedNestedEnum }, fieldNumber: 51),
     .packedEnum({ $0.repeatedForeignEnum }, fieldNumber: 52),
     .repeatedString({ $0.repeatedStringPiece }, fieldNumber: 54),
     .repeatedString({ $0.repeatedCord }, fieldNumber: 55),
-    .repeatedMessage({ $0.repeatedLazyMessage }, fieldNumber: 57),
+    .repeatedMessage({ $0._storage._repeatedLazyMessage }, fieldNumber: 57),
     .oneOf({ $0.oneofField }) {
       switch $0 {
       case .oneofUint32:
@@ -994,10 +994,10 @@ extension SwiftProtoTesting_Proto3_TestAllTypes: SwiftProtobuf.Message, SwiftPro
         return _oneOfField_oneofBytes
       }
     },
-    .singularMessage({ $0.optionalLazyImportMessage }, fieldNumber: 115, isUnset: { $0._storage._optionalLazyImportMessage == nil }),
+    .singularMessage({ $0._storage._optionalLazyImportMessage }, fieldNumber: 115),
   ]
   private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
-  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112)
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
 
@@ -1315,8 +1315,8 @@ extension SwiftProtoTesting_Proto3_NestedTestAllTypes: SwiftProtobuf.Message, Sw
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.child }, fieldNumber: 1, isUnset: { $0._storage._child == nil }),
-    .singularMessage({ $0.payload }, fieldNumber: 2, isUnset: { $0._storage._payload == nil }),
+    .singularMessage({ $0._storage._child }, fieldNumber: 1),
+    .singularMessage({ $0._storage._payload }, fieldNumber: 2),
   ]
 
 
@@ -1409,7 +1409,7 @@ extension SwiftProtoTesting_Proto3_TestProto2Required: SwiftProtobuf.Message, Sw
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.proto2 }, fieldNumber: 1, isUnset: { $0._proto2 == nil }),
+    .singularMessage({ $0._proto2 }, fieldNumber: 1),
   ]
 
 
diff --git a/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift b/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift
index 3fa4860c8..824f85d98 100644
--- a/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift
@@ -458,8 +458,8 @@ extension SwiftProtoTesting_TestProto3Optional: SwiftProtobuf.Message, SwiftProt
     .singularString({ $0.optionalString }, fieldNumber: 14, isUnset: { $0._storage._optionalString == nil }),
     .singularBytes({ $0.optionalBytes }, fieldNumber: 15, isUnset: { $0._storage._optionalBytes == nil }),
     .singularString({ $0.optionalCord }, fieldNumber: 16, isUnset: { $0._storage._optionalCord == nil }),
-    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalNestedMessage == nil }),
-    .singularMessage({ $0.lazyNestedMessage }, fieldNumber: 19, isUnset: { $0._storage._lazyNestedMessage == nil }),
+    .singularMessage({ $0._storage._optionalNestedMessage }, fieldNumber: 18),
+    .singularMessage({ $0._storage._lazyNestedMessage }, fieldNumber: 19),
     .singularEnum({ $0.optionalNestedEnum }, fieldNumber: 21, isUnset: { $0._storage._optionalNestedEnum == nil }),
     .singularInt32({ $0.singularInt32 }, fieldNumber: 22),
     .singularInt64({ $0.singularInt64 }, fieldNumber: 23),
diff --git a/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift
index bdcee6100..99af2e332 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift
@@ -1046,17 +1046,17 @@ extension SwiftProtoTesting_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPr
     .singularBool({ $0.requiredBool }, fieldNumber: 13, isUnset: { $0._storage._requiredBool == nil }),
     .singularString({ $0.requiredString }, fieldNumber: 14, isUnset: { $0._storage._requiredString == nil }),
     .singularBytes({ $0.requiredBytes }, fieldNumber: 15, isUnset: { $0._storage._requiredBytes == nil }),
-    .singularGroup({ $0.requiredGroup }, fieldNumber: 16, isUnset: { $0._storage._requiredGroup == nil }),
-    .singularMessage({ $0.requiredNestedMessage }, fieldNumber: 18, isUnset: { $0._storage._requiredNestedMessage == nil }),
-    .singularMessage({ $0.requiredForeignMessage }, fieldNumber: 19, isUnset: { $0._storage._requiredForeignMessage == nil }),
-    .singularMessage({ $0.requiredImportMessage }, fieldNumber: 20, isUnset: { $0._storage._requiredImportMessage == nil }),
+    .singularGroup({ $0._storage._requiredGroup }, fieldNumber: 16),
+    .singularMessage({ $0._storage._requiredNestedMessage }, fieldNumber: 18),
+    .singularMessage({ $0._storage._requiredForeignMessage }, fieldNumber: 19),
+    .singularMessage({ $0._storage._requiredImportMessage }, fieldNumber: 20),
     .singularEnum({ $0.requiredNestedEnum }, fieldNumber: 21, isUnset: { $0._storage._requiredNestedEnum == nil }),
     .singularEnum({ $0.requiredForeignEnum }, fieldNumber: 22, isUnset: { $0._storage._requiredForeignEnum == nil }),
     .singularEnum({ $0.requiredImportEnum }, fieldNumber: 23, isUnset: { $0._storage._requiredImportEnum == nil }),
     .singularString({ $0.requiredStringPiece }, fieldNumber: 24, isUnset: { $0._storage._requiredStringPiece == nil }),
     .singularString({ $0.requiredCord }, fieldNumber: 25, isUnset: { $0._storage._requiredCord == nil }),
-    .singularMessage({ $0.requiredPublicImportMessage }, fieldNumber: 26, isUnset: { $0._storage._requiredPublicImportMessage == nil }),
-    .singularMessage({ $0.requiredLazyMessage }, fieldNumber: 27, isUnset: { $0._storage._requiredLazyMessage == nil }),
+    .singularMessage({ $0._storage._requiredPublicImportMessage }, fieldNumber: 26),
+    .singularMessage({ $0._storage._requiredLazyMessage }, fieldNumber: 27),
     .singularInt32({ $0.defaultInt32 }, fieldNumber: 61, isUnset: { $0._storage._defaultInt32 == nil }),
     .singularInt64({ $0.defaultInt64 }, fieldNumber: 62, isUnset: { $0._storage._defaultInt64 == nil }),
     .singularUInt32({ $0.defaultUint32 }, fieldNumber: 63, isUnset: { $0._storage._defaultUint32 == nil }),
@@ -1091,7 +1091,7 @@ extension SwiftProtoTesting_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPr
     },
   ]
   private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
-  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112)
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
 
diff --git a/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift
index 07ae8a42e..94fe100dd 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift
@@ -219,9 +219,9 @@ extension SwiftProtoTesting_CycleFoo: SwiftProtobuf.Message, SwiftProtobuf._Mess
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.aFoo }, fieldNumber: 1, isUnset: { $0._storage._aFoo == nil }),
-    .singularMessage({ $0.aBar }, fieldNumber: 2, isUnset: { $0._storage._aBar == nil }),
-    .singularMessage({ $0.aBaz }, fieldNumber: 3, isUnset: { $0._storage._aBaz == nil }),
+    .singularMessage({ $0._storage._aFoo }, fieldNumber: 1),
+    .singularMessage({ $0._storage._aBar }, fieldNumber: 2),
+    .singularMessage({ $0._storage._aBaz }, fieldNumber: 3),
   ]
 
 
@@ -291,9 +291,9 @@ extension SwiftProtoTesting_CycleBar: SwiftProtobuf.Message, SwiftProtobuf._Mess
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.aBar }, fieldNumber: 1, isUnset: { $0._storage._aBar == nil }),
-    .singularMessage({ $0.aBaz }, fieldNumber: 2, isUnset: { $0._storage._aBaz == nil }),
-    .singularMessage({ $0.aFoo }, fieldNumber: 3, isUnset: { $0._storage._aFoo == nil }),
+    .singularMessage({ $0._storage._aBar }, fieldNumber: 1),
+    .singularMessage({ $0._storage._aBaz }, fieldNumber: 2),
+    .singularMessage({ $0._storage._aFoo }, fieldNumber: 3),
   ]
 
 
@@ -363,9 +363,9 @@ extension SwiftProtoTesting_CycleBaz: SwiftProtobuf.Message, SwiftProtobuf._Mess
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.aBaz }, fieldNumber: 1, isUnset: { $0._storage._aBaz == nil }),
-    .singularMessage({ $0.aFoo }, fieldNumber: 2, isUnset: { $0._storage._aFoo == nil }),
-    .singularMessage({ $0.aBar }, fieldNumber: 3, isUnset: { $0._storage._aBar == nil }),
+    .singularMessage({ $0._storage._aBaz }, fieldNumber: 1),
+    .singularMessage({ $0._storage._aFoo }, fieldNumber: 2),
+    .singularMessage({ $0._storage._aBar }, fieldNumber: 3),
   ]
 
 
diff --git a/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift
index 16cd00354..1eb9d99a6 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift
@@ -503,7 +503,7 @@ extension SwiftProtoTesting_Deprecated_MyMsg: SwiftProtobuf.Message, SwiftProtob
     .singularString({ $0.stringField }, fieldNumber: 1, isUnset: { $0._storage._stringField == nil }),
     .singularInt32({ $0.intField }, fieldNumber: 2, isUnset: { $0._storage._intField == nil }),
     .repeatedFixed32({ $0.fixedField }, fieldNumber: 3),
-    .singularMessage({ $0.msgField }, fieldNumber: 4, isUnset: { $0._storage._msgField == nil }),
+    .singularMessage({ $0._storage._msgField }, fieldNumber: 4),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 100, end: 536870912),
   ]
 
@@ -610,7 +610,7 @@ extension SwiftProtoTesting_Deprecated_MyMsg2: SwiftProtobuf.Message, SwiftProto
     .singularString({ $0.stringField }, fieldNumber: 1, isUnset: { $0._storage._stringField == nil }),
     .singularInt32({ $0.intField }, fieldNumber: 2, isUnset: { $0._storage._intField == nil }),
     .repeatedFixed32({ $0.fixedField }, fieldNumber: 3),
-    .singularMessage({ $0.msgField }, fieldNumber: 4, isUnset: { $0._storage._msgField == nil }),
+    .singularMessage({ $0._storage._msgField }, fieldNumber: 4),
   ]
 
 
diff --git a/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift
index 79c627921..4b50eb753 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift
@@ -213,7 +213,7 @@ extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage: SwiftProto
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.message }, fieldNumber: 1, isUnset: { $0._storage._message == nil }),
+    .singularMessage({ $0._storage._message }, fieldNumber: 1),
     .singularEnum({ $0.optionalEnum }, fieldNumber: 17, isUnset: { $0._storage._optionalEnum == nil }),
   ]
 
diff --git a/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift
index c4cd547aa..32738617c 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift
@@ -669,7 +669,7 @@ extension SwiftProtoTesting_Extend_MsgUsesStorage: SwiftProtobuf.Message, SwiftP
 
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.x }, fieldNumber: 1, isUnset: { $0._storage._x == nil }),
-    .singularMessage({ $0.y }, fieldNumber: 2, isUnset: { $0._storage._y == nil }),
+    .singularMessage({ $0._storage._y }, fieldNumber: 2),
     .extensionFields({ $0._protobuf_extensionFieldValues }, start: 100, end: 201),
   ]
 
diff --git a/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift
index 3b788ce69..e29d5764b 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift
@@ -461,7 +461,7 @@ extension SwiftProtoTesting_Order_TestFieldOrderings: SwiftProtobuf.Message, Swi
         return nil
       }
     },
-    .singularMessage({ $0.optionalNestedMessage }, fieldNumber: 200, isUnset: { $0._optionalNestedMessage == nil }),
+    .singularMessage({ $0._optionalNestedMessage }, fieldNumber: 200),
   ]
   private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 9, isUnset: { _ in false })
   private static let _oneOfField_oneofInt32: Field<Self> = .singularInt32({ $0.oneofInt32 }, fieldNumber: 10, isUnset: { _ in false })
diff --git a/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift
index 9346b084f..dc40c8c43 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift
@@ -478,7 +478,7 @@ extension SwiftTestNestingGroupsMessage: SwiftProtobuf.Message, SwiftProtobuf._M
 
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.outerA }, fieldNumber: 1, isUnset: { $0._outerA == nil }),
-    .singularGroup({ $0.subGroup1 }, fieldNumber: 2, isUnset: { $0._subGroup1 == nil }),
+    .singularGroup({ $0._subGroup1 }, fieldNumber: 2),
     .repeatedGroup({ $0.subGroup3 }, fieldNumber: 3),
   ]
 
@@ -514,7 +514,7 @@ extension SwiftTestNestingGroupsMessage.SubGroup1: SwiftProtobuf.Message, SwiftP
 
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.sub1A }, fieldNumber: 1, isUnset: { $0._sub1A == nil }),
-    .singularGroup({ $0.subGroup2 }, fieldNumber: 2, isUnset: { $0._subGroup2 == nil }),
+    .singularGroup({ $0._subGroup2 }, fieldNumber: 2),
   ]
 
 
diff --git a/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift
index 7cc6e12de..e47ea981c 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift
@@ -25244,7 +25244,7 @@ extension SwiftProtoTesting_Names_SpecialNames3: SwiftProtobuf.Message, SwiftPro
         return _oneOfField_str
       }
     },
-    .singularMessage({ $0.forcesStorage }, fieldNumber: 2, isUnset: { $0._storage._forcesStorage == nil }),
+    .singularMessage({ $0._storage._forcesStorage }, fieldNumber: 2),
   ]
   private static let _oneOfField_str: Field<Self> = .singularString({ $0.str }, fieldNumber: 1, isUnset: { _ in false })
 
@@ -25311,7 +25311,7 @@ extension SwiftProtoTesting_Names_SpecialNames4: SwiftProtobuf.Message, SwiftPro
 
   static let _fields: [Field<Self>] = [
     .singularString({ $0.newValue }, fieldNumber: 1, isUnset: { $0._storage._newValue == nil }),
-    .singularMessage({ $0.forcesStorage }, fieldNumber: 2, isUnset: { $0._storage._forcesStorage == nil }),
+    .singularMessage({ $0._storage._forcesStorage }, fieldNumber: 2),
   ]
 
 
diff --git a/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift
index c3c39bb38..af101167c 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift
@@ -356,9 +356,9 @@ extension SwiftProtoTesting_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf
       }
     },
   ]
-  private static let _oneOfField_option1: Field<Self> = .singularMessage({ $0.option1 }, fieldNumber: 1, isUnset: { _ in false })
-  private static let _oneOfField_option2: Field<Self> = .singularMessage({ $0.option2 }, fieldNumber: 2, isUnset: { _ in false })
-  private static let _oneOfField_option3: Field<Self> = .singularGroup({ $0.option3 }, fieldNumber: 3, isUnset: { _ in false })
+  private static let _oneOfField_option1: Field<Self> = .singularMessage({ $0.option1 }, fieldNumber: 1)
+  private static let _oneOfField_option2: Field<Self> = .singularMessage({ $0.option2 }, fieldNumber: 2)
+  private static let _oneOfField_option3: Field<Self> = .singularGroup({ $0.option3 }, fieldNumber: 3)
   private static let _oneOfField_option4: Field<Self> = .singularInt32({ $0.option4 }, fieldNumber: 6, isUnset: { _ in false })
 
 
diff --git a/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift
index 6ce4085b7..646c905c9 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift
@@ -244,7 +244,7 @@ extension SwiftProtoTesting_Merging_TestMessage: SwiftProtobuf.Message, SwiftPro
     },
   ]
   private static let _oneOfField_oneofUint32: Field<Self> = .singularUInt32({ $0.oneofUint32 }, fieldNumber: 111, isUnset: { _ in false })
-  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112, isUnset: { _ in false })
+  private static let _oneOfField_oneofNestedMessage: Field<Self> = .singularMessage({ $0.oneofNestedMessage }, fieldNumber: 112)
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 113, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 114, isUnset: { _ in false })
 
@@ -315,7 +315,7 @@ extension SwiftProtoTesting_Merging_TestParsingMerge: SwiftProtobuf.Message, Swi
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.optionalMessage }, fieldNumber: 1, isUnset: { $0._optionalMessage == nil }),
+    .singularMessage({ $0._optionalMessage }, fieldNumber: 1),
     .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 2),
   ]
 
diff --git a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift
index 92b915daa..191ec4c5b 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift
@@ -1252,8 +1252,8 @@ extension SwiftProtoTesting_Message2: SwiftProtobuf.Message, SwiftProtobuf._Mess
     .singularBool({ $0.optionalBool }, fieldNumber: 13, isUnset: { $0._storage._optionalBool == nil }),
     .singularString({ $0.optionalString }, fieldNumber: 14, isUnset: { $0._storage._optionalString == nil }),
     .singularBytes({ $0.optionalBytes }, fieldNumber: 15, isUnset: { $0._storage._optionalBytes == nil }),
-    .singularGroup({ $0.optionalGroup }, fieldNumber: 16, isUnset: { $0._storage._optionalGroup == nil }),
-    .singularMessage({ $0.optionalMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalMessage == nil }),
+    .singularGroup({ $0._storage._optionalGroup }, fieldNumber: 16),
+    .singularMessage({ $0._storage._optionalMessage }, fieldNumber: 18),
     .singularEnum({ $0.optionalEnum }, fieldNumber: 19, isUnset: { $0._storage._optionalEnum == nil }),
     .repeatedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
     .repeatedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
@@ -1270,8 +1270,8 @@ extension SwiftProtoTesting_Message2: SwiftProtobuf.Message, SwiftProtobuf._Mess
     .repeatedBool({ $0.repeatedBool }, fieldNumber: 43),
     .repeatedString({ $0.repeatedString }, fieldNumber: 44),
     .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
-    .repeatedGroup({ $0.repeatedGroup }, fieldNumber: 46),
-    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 48),
+    .repeatedGroup({ $0._storage._repeatedGroup }, fieldNumber: 46),
+    .repeatedMessage({ $0._storage._repeatedMessage }, fieldNumber: 48),
     .repeatedEnum({ $0.repeatedEnum }, fieldNumber: 49),
     .oneOf({ $0.o }) {
       switch $0 {
@@ -1313,25 +1313,25 @@ extension SwiftProtoTesting_Message2: SwiftProtobuf.Message, SwiftProtobuf._Mess
         return _oneOfField_oneofEnum
       }
     },
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 70),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 71),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 72),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 73),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 74),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 75),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 76),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 77),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 78),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 79),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 80),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 81),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 82),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 83),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0.mapStringBytes }, fieldNumber: 84),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Message2>.self, { $0.mapStringMessage }, fieldNumber: 85),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt32Bytes }, fieldNumber: 86),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message2.Enum>.self, { $0.mapInt32Enum }, fieldNumber: 87),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message2>.self, { $0.mapInt32Message }, fieldNumber: 88),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapInt32Int32 }, fieldNumber: 70),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapInt64Int64 }, fieldNumber: 71),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapUint32Uint32 }, fieldNumber: 72),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapUint64Uint64 }, fieldNumber: 73),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSint32Sint32 }, fieldNumber: 74),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSint64Sint64 }, fieldNumber: 75),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapFixed32Fixed32 }, fieldNumber: 76),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapFixed64Fixed64 }, fieldNumber: 77),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSfixed32Sfixed32 }, fieldNumber: 78),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSfixed64Sfixed64 }, fieldNumber: 79),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapInt32Float }, fieldNumber: 80),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapInt32Double }, fieldNumber: 81),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapBoolBool }, fieldNumber: 82),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapStringString }, fieldNumber: 83),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapStringBytes }, fieldNumber: 84),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Message2>.self, { $0._storage._mapStringMessage }, fieldNumber: 85),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapInt32Bytes }, fieldNumber: 86),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message2.Enum>.self, { $0._storage._mapInt32Enum }, fieldNumber: 87),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message2>.self, { $0._storage._mapInt32Message }, fieldNumber: 88),
   ]
   private static let _oneOfField_oneofInt32: Field<Self> = .singularInt32({ $0.oneofInt32 }, fieldNumber: 51, isUnset: { _ in false })
   private static let _oneOfField_oneofInt64: Field<Self> = .singularInt64({ $0.oneofInt64 }, fieldNumber: 52, isUnset: { _ in false })
@@ -1348,8 +1348,8 @@ extension SwiftProtoTesting_Message2: SwiftProtobuf.Message, SwiftProtobuf._Mess
   private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 63, isUnset: { _ in false })
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 64, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 65, isUnset: { _ in false })
-  private static let _oneOfField_oneofGroup: Field<Self> = .singularGroup({ $0.oneofGroup }, fieldNumber: 66, isUnset: { _ in false })
-  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 68, isUnset: { _ in false })
+  private static let _oneOfField_oneofGroup: Field<Self> = .singularGroup({ $0.oneofGroup }, fieldNumber: 66)
+  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 68)
   private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 69, isUnset: { _ in false })
 
 
@@ -1586,7 +1586,7 @@ extension SwiftProtoTesting_Msg2UsesStorage: SwiftProtobuf.Message, SwiftProtobu
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.y }, fieldNumber: 999, isUnset: { $0._storage._y == nil }),
+    .singularMessage({ $0._storage._y }, fieldNumber: 999),
   ]
 
 
@@ -1668,7 +1668,7 @@ extension SwiftProtoTesting_Msg2NamesUsesStorage: SwiftProtobuf.Message, SwiftPr
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.isInitialized_p }, fieldNumber: 1, isUnset: { $0._isInitialized_p == nil }),
     .singularInt32({ $0.debugDescription_p }, fieldNumber: 2, isUnset: { $0._debugDescription_p == nil }),
-    .singularMessage({ $0.value }, fieldNumber: 3, isUnset: { $0._value == nil }),
+    .singularMessage({ $0._value }, fieldNumber: 3),
   ]
 
 
diff --git a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift
index da7015d6a..292de98a0 100644
--- a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift
@@ -1043,7 +1043,7 @@ extension SwiftProtoTesting_Message3: SwiftProtobuf.Message, SwiftProtobuf._Mess
     .singularBool({ $0.optionalBool }, fieldNumber: 13),
     .singularString({ $0.optionalString }, fieldNumber: 14),
     .singularBytes({ $0.optionalBytes }, fieldNumber: 15),
-    .singularMessage({ $0.optionalMessage }, fieldNumber: 18, isUnset: { $0._storage._optionalMessage == nil }),
+    .singularMessage({ $0._storage._optionalMessage }, fieldNumber: 18),
     .singularEnum({ $0.optionalEnum }, fieldNumber: 19, defaultValue: .foo),
     .packedInt32({ $0.repeatedInt32 }, fieldNumber: 31),
     .packedInt64({ $0.repeatedInt64 }, fieldNumber: 32),
@@ -1060,7 +1060,7 @@ extension SwiftProtoTesting_Message3: SwiftProtobuf.Message, SwiftProtobuf._Mess
     .packedBool({ $0.repeatedBool }, fieldNumber: 43),
     .repeatedString({ $0.repeatedString }, fieldNumber: 44),
     .repeatedBytes({ $0.repeatedBytes }, fieldNumber: 45),
-    .repeatedMessage({ $0.repeatedMessage }, fieldNumber: 48),
+    .repeatedMessage({ $0._storage._repeatedMessage }, fieldNumber: 48),
     .packedEnum({ $0.repeatedEnum }, fieldNumber: 49),
     .oneOf({ $0.o }) {
       switch $0 {
@@ -1100,25 +1100,25 @@ extension SwiftProtoTesting_Message3: SwiftProtobuf.Message, SwiftProtobuf._Mess
         return _oneOfField_oneofEnum
       }
     },
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0.mapInt32Int32 }, fieldNumber: 70),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0.mapInt64Int64 }, fieldNumber: 71),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0.mapUint32Uint32 }, fieldNumber: 72),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0.mapUint64Uint64 }, fieldNumber: 73),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0.mapSint32Sint32 }, fieldNumber: 74),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0.mapSint64Sint64 }, fieldNumber: 75),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0.mapFixed32Fixed32 }, fieldNumber: 76),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0.mapFixed64Fixed64 }, fieldNumber: 77),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0.mapSfixed32Sfixed32 }, fieldNumber: 78),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0.mapSfixed64Sfixed64 }, fieldNumber: 79),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0.mapInt32Float }, fieldNumber: 80),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0.mapInt32Double }, fieldNumber: 81),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0.mapBoolBool }, fieldNumber: 82),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0.mapStringString }, fieldNumber: 83),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0.mapStringBytes }, fieldNumber: 84),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Message3>.self, { $0.mapStringMessage }, fieldNumber: 85),
-    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0.mapInt32Bytes }, fieldNumber: 86),
-    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message3.Enum>.self, { $0.mapInt32Enum }, fieldNumber: 87),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message3>.self, { $0.mapInt32Message }, fieldNumber: 88),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufInt32>.self, { $0._storage._mapInt32Int32 }, fieldNumber: 70),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt64,SwiftProtobuf.ProtobufInt64>.self, { $0._storage._mapInt64Int64 }, fieldNumber: 71),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt32,SwiftProtobuf.ProtobufUInt32>.self, { $0._storage._mapUint32Uint32 }, fieldNumber: 72),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufUInt64,SwiftProtobuf.ProtobufUInt64>.self, { $0._storage._mapUint64Uint64 }, fieldNumber: 73),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt32,SwiftProtobuf.ProtobufSInt32>.self, { $0._storage._mapSint32Sint32 }, fieldNumber: 74),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSInt64,SwiftProtobuf.ProtobufSInt64>.self, { $0._storage._mapSint64Sint64 }, fieldNumber: 75),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed32,SwiftProtobuf.ProtobufFixed32>.self, { $0._storage._mapFixed32Fixed32 }, fieldNumber: 76),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufFixed64,SwiftProtobuf.ProtobufFixed64>.self, { $0._storage._mapFixed64Fixed64 }, fieldNumber: 77),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed32,SwiftProtobuf.ProtobufSFixed32>.self, { $0._storage._mapSfixed32Sfixed32 }, fieldNumber: 78),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufSFixed64,SwiftProtobuf.ProtobufSFixed64>.self, { $0._storage._mapSfixed64Sfixed64 }, fieldNumber: 79),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufFloat>.self, { $0._storage._mapInt32Float }, fieldNumber: 80),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufDouble>.self, { $0._storage._mapInt32Double }, fieldNumber: 81),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufBool,SwiftProtobuf.ProtobufBool>.self, { $0._storage._mapBoolBool }, fieldNumber: 82),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, { $0._storage._mapStringString }, fieldNumber: 83),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapStringBytes }, fieldNumber: 84),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SwiftProtoTesting_Message3>.self, { $0._storage._mapStringMessage }, fieldNumber: 85),
+    .map(type: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.ProtobufBytes>.self, { $0._storage._mapInt32Bytes }, fieldNumber: 86),
+    .map(type: SwiftProtobuf._ProtobufEnumMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message3.Enum>.self, { $0._storage._mapInt32Enum }, fieldNumber: 87),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtoTesting_Message3>.self, { $0._storage._mapInt32Message }, fieldNumber: 88),
   ]
   private static let _oneOfField_oneofInt32: Field<Self> = .singularInt32({ $0.oneofInt32 }, fieldNumber: 51, isUnset: { _ in false })
   private static let _oneOfField_oneofInt64: Field<Self> = .singularInt64({ $0.oneofInt64 }, fieldNumber: 52, isUnset: { _ in false })
@@ -1135,7 +1135,7 @@ extension SwiftProtoTesting_Message3: SwiftProtobuf.Message, SwiftProtobuf._Mess
   private static let _oneOfField_oneofBool: Field<Self> = .singularBool({ $0.oneofBool }, fieldNumber: 63, isUnset: { _ in false })
   private static let _oneOfField_oneofString: Field<Self> = .singularString({ $0.oneofString }, fieldNumber: 64, isUnset: { _ in false })
   private static let _oneOfField_oneofBytes: Field<Self> = .singularBytes({ $0.oneofBytes }, fieldNumber: 65, isUnset: { _ in false })
-  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 68, isUnset: { _ in false })
+  private static let _oneOfField_oneofMessage: Field<Self> = .singularMessage({ $0.oneofMessage }, fieldNumber: 68)
   private static let _oneOfField_oneofEnum: Field<Self> = .singularEnum({ $0.oneofEnum }, fieldNumber: 69, isUnset: { _ in false })
 
 
@@ -1276,7 +1276,7 @@ extension SwiftProtoTesting_Msg3UsesStorage: SwiftProtobuf.Message, SwiftProtobu
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.y }, fieldNumber: 999, isUnset: { $0._storage._y == nil }),
+    .singularMessage({ $0._storage._y }, fieldNumber: 999),
   ]
 
 
@@ -1358,7 +1358,7 @@ extension SwiftProtoTesting_Msg3NamesUsesStorage: SwiftProtobuf.Message, SwiftPr
   static let _fields: [Field<Self>] = [
     .singularInt32({ $0.isInitialized_p }, fieldNumber: 1),
     .singularInt32({ $0.debugDescription_p }, fieldNumber: 2),
-    .singularMessage({ $0.value }, fieldNumber: 3, isUnset: { $0._value == nil }),
+    .singularMessage({ $0._value }, fieldNumber: 3),
   ]
 
 
diff --git a/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift b/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift
index 5d0837329..26b4c591e 100644
--- a/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift
+++ b/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift
@@ -741,25 +741,25 @@ extension SwiftProtoTesting_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProt
   }
 
   static let _fields: [Field<Self>] = [
-    .singularMessage({ $0.anyField }, fieldNumber: 1, isUnset: { $0._storage._anyField == nil }),
-    .singularMessage({ $0.apiField }, fieldNumber: 2, isUnset: { $0._storage._apiField == nil }),
-    .singularMessage({ $0.durationField }, fieldNumber: 3, isUnset: { $0._storage._durationField == nil }),
-    .singularMessage({ $0.emptyField }, fieldNumber: 4, isUnset: { $0._storage._emptyField == nil }),
-    .singularMessage({ $0.fieldMaskField }, fieldNumber: 5, isUnset: { $0._storage._fieldMaskField == nil }),
-    .singularMessage({ $0.sourceContextField }, fieldNumber: 6, isUnset: { $0._storage._sourceContextField == nil }),
-    .singularMessage({ $0.structField }, fieldNumber: 7, isUnset: { $0._storage._structField == nil }),
-    .singularMessage({ $0.timestampField }, fieldNumber: 8, isUnset: { $0._storage._timestampField == nil }),
-    .singularMessage({ $0.typeField }, fieldNumber: 9, isUnset: { $0._storage._typeField == nil }),
-    .singularMessage({ $0.doubleField }, fieldNumber: 10, isUnset: { $0._storage._doubleField == nil }),
-    .singularMessage({ $0.floatField }, fieldNumber: 11, isUnset: { $0._storage._floatField == nil }),
-    .singularMessage({ $0.int64Field }, fieldNumber: 12, isUnset: { $0._storage._int64Field == nil }),
-    .singularMessage({ $0.uint64Field }, fieldNumber: 13, isUnset: { $0._storage._uint64Field == nil }),
-    .singularMessage({ $0.int32Field }, fieldNumber: 14, isUnset: { $0._storage._int32Field == nil }),
-    .singularMessage({ $0.uint32Field }, fieldNumber: 15, isUnset: { $0._storage._uint32Field == nil }),
-    .singularMessage({ $0.boolField }, fieldNumber: 16, isUnset: { $0._storage._boolField == nil }),
-    .singularMessage({ $0.stringField }, fieldNumber: 17, isUnset: { $0._storage._stringField == nil }),
-    .singularMessage({ $0.bytesField }, fieldNumber: 18, isUnset: { $0._storage._bytesField == nil }),
-    .singularMessage({ $0.valueField }, fieldNumber: 19, isUnset: { $0._storage._valueField == nil }),
+    .singularMessage({ $0._storage._anyField }, fieldNumber: 1),
+    .singularMessage({ $0._storage._apiField }, fieldNumber: 2),
+    .singularMessage({ $0._storage._durationField }, fieldNumber: 3),
+    .singularMessage({ $0._storage._emptyField }, fieldNumber: 4),
+    .singularMessage({ $0._storage._fieldMaskField }, fieldNumber: 5),
+    .singularMessage({ $0._storage._sourceContextField }, fieldNumber: 6),
+    .singularMessage({ $0._storage._structField }, fieldNumber: 7),
+    .singularMessage({ $0._storage._timestampField }, fieldNumber: 8),
+    .singularMessage({ $0._storage._typeField }, fieldNumber: 9),
+    .singularMessage({ $0._storage._doubleField }, fieldNumber: 10),
+    .singularMessage({ $0._storage._floatField }, fieldNumber: 11),
+    .singularMessage({ $0._storage._int64Field }, fieldNumber: 12),
+    .singularMessage({ $0._storage._uint64Field }, fieldNumber: 13),
+    .singularMessage({ $0._storage._int32Field }, fieldNumber: 14),
+    .singularMessage({ $0._storage._uint32Field }, fieldNumber: 15),
+    .singularMessage({ $0._storage._boolField }, fieldNumber: 16),
+    .singularMessage({ $0._storage._stringField }, fieldNumber: 17),
+    .singularMessage({ $0._storage._bytesField }, fieldNumber: 18),
+    .singularMessage({ $0._storage._valueField }, fieldNumber: 19),
   ]
 
 
@@ -905,24 +905,24 @@ extension SwiftProtoTesting_RepeatedWellKnownTypes: SwiftProtobuf.Message, Swift
   }
 
   static let _fields: [Field<Self>] = [
-    .repeatedMessage({ $0.anyField }, fieldNumber: 1),
-    .repeatedMessage({ $0.apiField }, fieldNumber: 2),
-    .repeatedMessage({ $0.durationField }, fieldNumber: 3),
-    .repeatedMessage({ $0.emptyField }, fieldNumber: 4),
-    .repeatedMessage({ $0.fieldMaskField }, fieldNumber: 5),
-    .repeatedMessage({ $0.sourceContextField }, fieldNumber: 6),
-    .repeatedMessage({ $0.structField }, fieldNumber: 7),
-    .repeatedMessage({ $0.timestampField }, fieldNumber: 8),
-    .repeatedMessage({ $0.typeField }, fieldNumber: 9),
-    .repeatedMessage({ $0.doubleField }, fieldNumber: 10),
-    .repeatedMessage({ $0.floatField }, fieldNumber: 11),
-    .repeatedMessage({ $0.int64Field }, fieldNumber: 12),
-    .repeatedMessage({ $0.uint64Field }, fieldNumber: 13),
-    .repeatedMessage({ $0.int32Field }, fieldNumber: 14),
-    .repeatedMessage({ $0.uint32Field }, fieldNumber: 15),
-    .repeatedMessage({ $0.boolField }, fieldNumber: 16),
-    .repeatedMessage({ $0.stringField }, fieldNumber: 17),
-    .repeatedMessage({ $0.bytesField }, fieldNumber: 18),
+    .repeatedMessage({ $0._storage._anyField }, fieldNumber: 1),
+    .repeatedMessage({ $0._storage._apiField }, fieldNumber: 2),
+    .repeatedMessage({ $0._storage._durationField }, fieldNumber: 3),
+    .repeatedMessage({ $0._storage._emptyField }, fieldNumber: 4),
+    .repeatedMessage({ $0._storage._fieldMaskField }, fieldNumber: 5),
+    .repeatedMessage({ $0._storage._sourceContextField }, fieldNumber: 6),
+    .repeatedMessage({ $0._storage._structField }, fieldNumber: 7),
+    .repeatedMessage({ $0._storage._timestampField }, fieldNumber: 8),
+    .repeatedMessage({ $0._storage._typeField }, fieldNumber: 9),
+    .repeatedMessage({ $0._storage._doubleField }, fieldNumber: 10),
+    .repeatedMessage({ $0._storage._floatField }, fieldNumber: 11),
+    .repeatedMessage({ $0._storage._int64Field }, fieldNumber: 12),
+    .repeatedMessage({ $0._storage._uint64Field }, fieldNumber: 13),
+    .repeatedMessage({ $0._storage._int32Field }, fieldNumber: 14),
+    .repeatedMessage({ $0._storage._uint32Field }, fieldNumber: 15),
+    .repeatedMessage({ $0._storage._boolField }, fieldNumber: 16),
+    .repeatedMessage({ $0._storage._stringField }, fieldNumber: 17),
+    .repeatedMessage({ $0._storage._bytesField }, fieldNumber: 18),
   ]
 
 
@@ -1268,24 +1268,24 @@ extension SwiftProtoTesting_OneofWellKnownTypes: SwiftProtobuf.Message, SwiftPro
       }
     },
   ]
-  private static let _oneOfField_anyField: Field<Self> = .singularMessage({ $0.anyField }, fieldNumber: 1, isUnset: { _ in false })
-  private static let _oneOfField_apiField: Field<Self> = .singularMessage({ $0.apiField }, fieldNumber: 2, isUnset: { _ in false })
-  private static let _oneOfField_durationField: Field<Self> = .singularMessage({ $0.durationField }, fieldNumber: 3, isUnset: { _ in false })
-  private static let _oneOfField_emptyField: Field<Self> = .singularMessage({ $0.emptyField }, fieldNumber: 4, isUnset: { _ in false })
-  private static let _oneOfField_fieldMaskField: Field<Self> = .singularMessage({ $0.fieldMaskField }, fieldNumber: 5, isUnset: { _ in false })
-  private static let _oneOfField_sourceContextField: Field<Self> = .singularMessage({ $0.sourceContextField }, fieldNumber: 6, isUnset: { _ in false })
-  private static let _oneOfField_structField: Field<Self> = .singularMessage({ $0.structField }, fieldNumber: 7, isUnset: { _ in false })
-  private static let _oneOfField_timestampField: Field<Self> = .singularMessage({ $0.timestampField }, fieldNumber: 8, isUnset: { _ in false })
-  private static let _oneOfField_typeField: Field<Self> = .singularMessage({ $0.typeField }, fieldNumber: 9, isUnset: { _ in false })
-  private static let _oneOfField_doubleField: Field<Self> = .singularMessage({ $0.doubleField }, fieldNumber: 10, isUnset: { _ in false })
-  private static let _oneOfField_floatField: Field<Self> = .singularMessage({ $0.floatField }, fieldNumber: 11, isUnset: { _ in false })
-  private static let _oneOfField_int64Field: Field<Self> = .singularMessage({ $0.int64Field }, fieldNumber: 12, isUnset: { _ in false })
-  private static let _oneOfField_uint64Field: Field<Self> = .singularMessage({ $0.uint64Field }, fieldNumber: 13, isUnset: { _ in false })
-  private static let _oneOfField_int32Field: Field<Self> = .singularMessage({ $0.int32Field }, fieldNumber: 14, isUnset: { _ in false })
-  private static let _oneOfField_uint32Field: Field<Self> = .singularMessage({ $0.uint32Field }, fieldNumber: 15, isUnset: { _ in false })
-  private static let _oneOfField_boolField: Field<Self> = .singularMessage({ $0.boolField }, fieldNumber: 16, isUnset: { _ in false })
-  private static let _oneOfField_stringField: Field<Self> = .singularMessage({ $0.stringField }, fieldNumber: 17, isUnset: { _ in false })
-  private static let _oneOfField_bytesField: Field<Self> = .singularMessage({ $0.bytesField }, fieldNumber: 18, isUnset: { _ in false })
+  private static let _oneOfField_anyField: Field<Self> = .singularMessage({ $0.anyField }, fieldNumber: 1)
+  private static let _oneOfField_apiField: Field<Self> = .singularMessage({ $0.apiField }, fieldNumber: 2)
+  private static let _oneOfField_durationField: Field<Self> = .singularMessage({ $0.durationField }, fieldNumber: 3)
+  private static let _oneOfField_emptyField: Field<Self> = .singularMessage({ $0.emptyField }, fieldNumber: 4)
+  private static let _oneOfField_fieldMaskField: Field<Self> = .singularMessage({ $0.fieldMaskField }, fieldNumber: 5)
+  private static let _oneOfField_sourceContextField: Field<Self> = .singularMessage({ $0.sourceContextField }, fieldNumber: 6)
+  private static let _oneOfField_structField: Field<Self> = .singularMessage({ $0.structField }, fieldNumber: 7)
+  private static let _oneOfField_timestampField: Field<Self> = .singularMessage({ $0.timestampField }, fieldNumber: 8)
+  private static let _oneOfField_typeField: Field<Self> = .singularMessage({ $0.typeField }, fieldNumber: 9)
+  private static let _oneOfField_doubleField: Field<Self> = .singularMessage({ $0.doubleField }, fieldNumber: 10)
+  private static let _oneOfField_floatField: Field<Self> = .singularMessage({ $0.floatField }, fieldNumber: 11)
+  private static let _oneOfField_int64Field: Field<Self> = .singularMessage({ $0.int64Field }, fieldNumber: 12)
+  private static let _oneOfField_uint64Field: Field<Self> = .singularMessage({ $0.uint64Field }, fieldNumber: 13)
+  private static let _oneOfField_int32Field: Field<Self> = .singularMessage({ $0.int32Field }, fieldNumber: 14)
+  private static let _oneOfField_uint32Field: Field<Self> = .singularMessage({ $0.uint32Field }, fieldNumber: 15)
+  private static let _oneOfField_boolField: Field<Self> = .singularMessage({ $0.boolField }, fieldNumber: 16)
+  private static let _oneOfField_stringField: Field<Self> = .singularMessage({ $0.stringField }, fieldNumber: 17)
+  private static let _oneOfField_bytesField: Field<Self> = .singularMessage({ $0.bytesField }, fieldNumber: 18)
 
 
   static func ==(lhs: SwiftProtoTesting_OneofWellKnownTypes, rhs: SwiftProtoTesting_OneofWellKnownTypes) -> Bool {
@@ -1404,24 +1404,24 @@ extension SwiftProtoTesting_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProto
   }
 
   static let _fields: [Field<Self>] = [
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Any>.self, { $0.anyField }, fieldNumber: 1),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Api>.self, { $0.apiField }, fieldNumber: 2),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Duration>.self, { $0.durationField }, fieldNumber: 3),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Empty>.self, { $0.emptyField }, fieldNumber: 4),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_FieldMask>.self, { $0.fieldMaskField }, fieldNumber: 5),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_SourceContext>.self, { $0.sourceContextField }, fieldNumber: 6),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Struct>.self, { $0.structField }, fieldNumber: 7),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Timestamp>.self, { $0.timestampField }, fieldNumber: 8),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Type>.self, { $0.typeField }, fieldNumber: 9),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_DoubleValue>.self, { $0.doubleField }, fieldNumber: 10),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_FloatValue>.self, { $0.floatField }, fieldNumber: 11),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Int64Value>.self, { $0.int64Field }, fieldNumber: 12),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_UInt64Value>.self, { $0.uint64Field }, fieldNumber: 13),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Int32Value>.self, { $0.int32Field }, fieldNumber: 14),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_UInt32Value>.self, { $0.uint32Field }, fieldNumber: 15),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_BoolValue>.self, { $0.boolField }, fieldNumber: 16),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_StringValue>.self, { $0.stringField }, fieldNumber: 17),
-    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_BytesValue>.self, { $0.bytesField }, fieldNumber: 18),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Any>.self, { $0._storage._anyField }, fieldNumber: 1),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Api>.self, { $0._storage._apiField }, fieldNumber: 2),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Duration>.self, { $0._storage._durationField }, fieldNumber: 3),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Empty>.self, { $0._storage._emptyField }, fieldNumber: 4),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_FieldMask>.self, { $0._storage._fieldMaskField }, fieldNumber: 5),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_SourceContext>.self, { $0._storage._sourceContextField }, fieldNumber: 6),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Struct>.self, { $0._storage._structField }, fieldNumber: 7),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Timestamp>.self, { $0._storage._timestampField }, fieldNumber: 8),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Type>.self, { $0._storage._typeField }, fieldNumber: 9),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_DoubleValue>.self, { $0._storage._doubleField }, fieldNumber: 10),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_FloatValue>.self, { $0._storage._floatField }, fieldNumber: 11),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Int64Value>.self, { $0._storage._int64Field }, fieldNumber: 12),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_UInt64Value>.self, { $0._storage._uint64Field }, fieldNumber: 13),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_Int32Value>.self, { $0._storage._int32Field }, fieldNumber: 14),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_UInt32Value>.self, { $0._storage._uint32Field }, fieldNumber: 15),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_BoolValue>.self, { $0._storage._boolField }, fieldNumber: 16),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_StringValue>.self, { $0._storage._stringField }, fieldNumber: 17),
+    .map(type: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt32,SwiftProtobuf.Google_Protobuf_BytesValue>.self, { $0._storage._bytesField }, fieldNumber: 18),
   ]