diff --git a/Reference/Conformance/conformance/conformance.pb.swift b/Reference/Conformance/conformance/conformance.pb.swift index 341e78995..c58ddc190 100644 --- a/Reference/Conformance/conformance/conformance.pb.swift +++ b/Reference/Conformance/conformance/conformance.pb.swift @@ -142,6 +142,27 @@ enum Conformance_TestCategory: SwiftProtobuf.Enum, Swift.CaseIterable { } +/// Meant to encapsulate all types of tests: successes, skips, failures, etc. +/// Therefore, this may or may not have a failure message. Failure messages +/// may be truncated for our failure lists. +struct Conformance_TestStatus: 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 name: String = String() + + var failureMessage: String = String() + + /// What an actual test name matched to in a failure list. Can be wildcarded or + /// an exact match without wildcards. + var matchedName: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + /// The conformance runner will request a list of failures as the first request. /// This will be known by message_type == "conformance.FailureSet", a conformance /// test should return a serialized FailureSet in protobuf_payload. @@ -150,7 +171,7 @@ struct Conformance_FailureSet: Sendable { // `Message` and `Message+*Additions` files in the SwiftProtobuf library for // methods supported on all messages. - var failure: [String] = [] + var test: [Conformance_TestStatus] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -441,10 +462,54 @@ extension Conformance_TestCategory: SwiftProtobuf._ProtoNameProviding { ] } +extension Conformance_TestStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestStatus" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "name"), + 2: .standard(proto: "failure_message"), + 3: .standard(proto: "matched_name"), + ] + + mutating func decodeMessage(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.decodeSingularStringField(value: &self.name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.failureMessage) }() + case 3: try { try decoder.decodeSingularStringField(value: &self.matchedName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.failureMessage.isEmpty { + try visitor.visitSingularStringField(value: self.failureMessage, fieldNumber: 2) + } + if !self.matchedName.isEmpty { + try visitor.visitSingularStringField(value: self.matchedName, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Conformance_TestStatus, rhs: Conformance_TestStatus) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.failureMessage != rhs.failureMessage {return false} + if lhs.matchedName != rhs.matchedName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FailureSet" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "failure"), + 2: .same(proto: "test"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -453,21 +518,21 @@ extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageI // 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.decodeRepeatedStringField(value: &self.failure) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.test) }() default: break } } } func traverse(visitor: inout V) throws { - if !self.failure.isEmpty { - try visitor.visitRepeatedStringField(value: self.failure, fieldNumber: 1) + if !self.test.isEmpty { + try visitor.visitRepeatedMessageField(value: self.test, fieldNumber: 2) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Conformance_FailureSet, rhs: Conformance_FailureSet) -> Bool { - if lhs.failure != rhs.failure {return false} + if lhs.test != rhs.test {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/Reference/upstream/conformance/conformance.pb.swift b/Reference/upstream/conformance/conformance.pb.swift index 341e78995..c58ddc190 100644 --- a/Reference/upstream/conformance/conformance.pb.swift +++ b/Reference/upstream/conformance/conformance.pb.swift @@ -142,6 +142,27 @@ enum Conformance_TestCategory: SwiftProtobuf.Enum, Swift.CaseIterable { } +/// Meant to encapsulate all types of tests: successes, skips, failures, etc. +/// Therefore, this may or may not have a failure message. Failure messages +/// may be truncated for our failure lists. +struct Conformance_TestStatus: 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 name: String = String() + + var failureMessage: String = String() + + /// What an actual test name matched to in a failure list. Can be wildcarded or + /// an exact match without wildcards. + var matchedName: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + /// The conformance runner will request a list of failures as the first request. /// This will be known by message_type == "conformance.FailureSet", a conformance /// test should return a serialized FailureSet in protobuf_payload. @@ -150,7 +171,7 @@ struct Conformance_FailureSet: Sendable { // `Message` and `Message+*Additions` files in the SwiftProtobuf library for // methods supported on all messages. - var failure: [String] = [] + var test: [Conformance_TestStatus] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -441,10 +462,54 @@ extension Conformance_TestCategory: SwiftProtobuf._ProtoNameProviding { ] } +extension Conformance_TestStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestStatus" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "name"), + 2: .standard(proto: "failure_message"), + 3: .standard(proto: "matched_name"), + ] + + mutating func decodeMessage(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.decodeSingularStringField(value: &self.name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.failureMessage) }() + case 3: try { try decoder.decodeSingularStringField(value: &self.matchedName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.failureMessage.isEmpty { + try visitor.visitSingularStringField(value: self.failureMessage, fieldNumber: 2) + } + if !self.matchedName.isEmpty { + try visitor.visitSingularStringField(value: self.matchedName, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Conformance_TestStatus, rhs: Conformance_TestStatus) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.failureMessage != rhs.failureMessage {return false} + if lhs.matchedName != rhs.matchedName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FailureSet" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "failure"), + 2: .same(proto: "test"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -453,21 +518,21 @@ extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageI // 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.decodeRepeatedStringField(value: &self.failure) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.test) }() default: break } } } func traverse(visitor: inout V) throws { - if !self.failure.isEmpty { - try visitor.visitRepeatedStringField(value: self.failure, fieldNumber: 1) + if !self.test.isEmpty { + try visitor.visitRepeatedMessageField(value: self.test, fieldNumber: 2) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Conformance_FailureSet, rhs: Conformance_FailureSet) -> Bool { - if lhs.failure != rhs.failure {return false} + if lhs.test != rhs.test {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/Reference/upstream/google/protobuf/cpp_features.pb.swift b/Reference/upstream/google/protobuf/cpp_features.pb.swift index 3d2d6ff54..87fc79edb 100644 --- a/Reference/upstream/google/protobuf/cpp_features.pb.swift +++ b/Reference/upstream/google/protobuf/cpp_features.pb.swift @@ -55,6 +55,15 @@ struct Pb_CppFeatures: Sendable { /// Clears the value of `stringType`. Subsequent reads from it will return its default value. mutating func clearStringType() {self._stringType = nil} + var enumNameUsesStringView: Bool { + get {return _enumNameUsesStringView ?? false} + set {_enumNameUsesStringView = newValue} + } + /// Returns true if `enumNameUsesStringView` has been explicitly set. + var hasEnumNameUsesStringView: Bool {return self._enumNameUsesStringView != nil} + /// Clears the value of `enumNameUsesStringView`. Subsequent reads from it will return its default value. + mutating func clearEnumNameUsesStringView() {self._enumNameUsesStringView = nil} + var unknownFields = SwiftProtobuf.UnknownStorage() enum StringType: SwiftProtobuf.Enum, Swift.CaseIterable { @@ -93,6 +102,7 @@ struct Pb_CppFeatures: Sendable { fileprivate var _legacyClosedEnum: Bool? = nil fileprivate var _stringType: Pb_CppFeatures.StringType? = nil + fileprivate var _enumNameUsesStringView: Bool? = nil } // MARK: - Extension support defined in cpp_features.proto. @@ -151,6 +161,7 @@ extension Pb_CppFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .standard(proto: "legacy_closed_enum"), 2: .standard(proto: "string_type"), + 3: .standard(proto: "enum_name_uses_string_view"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -161,6 +172,7 @@ extension Pb_CppFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement switch fieldNumber { case 1: try { try decoder.decodeSingularBoolField(value: &self._legacyClosedEnum) }() case 2: try { try decoder.decodeSingularEnumField(value: &self._stringType) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._enumNameUsesStringView) }() default: break } } @@ -177,12 +189,16 @@ extension Pb_CppFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement try { if let v = self._stringType { try visitor.visitSingularEnumField(value: v, fieldNumber: 2) } }() + try { if let v = self._enumNameUsesStringView { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Pb_CppFeatures, rhs: Pb_CppFeatures) -> Bool { if lhs._legacyClosedEnum != rhs._legacyClosedEnum {return false} if lhs._stringType != rhs._stringType {return false} + if lhs._enumNameUsesStringView != rhs._enumNameUsesStringView {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/Reference/upstream/google/protobuf/unittest_lite.pb.swift b/Reference/upstream/google/protobuf/unittest_lite.pb.swift index c45283c0a..2afdcfdde 100644 --- a/Reference/upstream/google/protobuf/unittest_lite.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_lite.pb.swift @@ -1712,6 +1712,27 @@ struct ProtobufUnittest_RecursiveMessage: @unchecked Sendable { fileprivate var _storage = _StorageClass.defaultInstance } +struct ProtobufUnittest_RecursiveGroup: @unchecked 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 recurse: ProtobufUnittest_RecursiveGroup { + get {return _storage._recurse ?? ProtobufUnittest_RecursiveGroup()} + set {_uniqueStorage()._recurse = newValue} + } + /// Returns true if `recurse` has been explicitly set. + var hasRecurse: Bool {return _storage._recurse != nil} + /// Clears the value of `recurse`. Subsequent reads from it will return its default value. + mutating func clearRecurse() {_uniqueStorage()._recurse = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + // MARK: - Extension support defined in unittest_lite.proto. // MARK: - Extension Properties @@ -5778,3 +5799,79 @@ extension ProtobufUnittest_RecursiveMessage: SwiftProtobuf.Message, SwiftProtobu return true } } + +extension ProtobufUnittest_RecursiveGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RecursiveGroup" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "recurse"), + ] + + fileprivate class _StorageClass { + var _recurse: ProtobufUnittest_RecursiveGroup? = nil + + #if swift(>=5.10) + // This property is used as the initial default value for new instances of the type. + // The type itself is protecting the reference to its storage via CoW semantics. + // This will force a copy to be made of this reference when the first mutation occurs; + // hence, it is safe to mark this as `nonisolated(unsafe)`. + static nonisolated(unsafe) let defaultInstance = _StorageClass() + #else + static let defaultInstance = _StorageClass() + #endif + + private init() {} + + init(copying source: _StorageClass) { + _recurse = source._recurse + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(decoder: inout D) throws { + _ = _uniqueStorage() + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + 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.decodeSingularGroupField(value: &_storage._recurse) }() + default: break + } + } + } + } + + func traverse(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._recurse { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufUnittest_RecursiveGroup, rhs: ProtobufUnittest_RecursiveGroup) -> Bool { + if lhs._storage !== rhs._storage { + let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in + let _storage = _args.0 + let rhs_storage = _args.1 + if _storage._recurse != rhs_storage._recurse {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_no_field_presence.pb.swift b/Reference/upstream/google/protobuf/unittest_no_field_presence.pb.swift index 6a6e3b527..e896cc7cd 100644 --- a/Reference/upstream/google/protobuf/unittest_no_field_presence.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_no_field_presence.pb.swift @@ -466,6 +466,29 @@ struct Proto2NofieldpresenceUnittest_ForeignMessage: Sendable { init() {} } +/// Same as ForeignMessage, but all fields have explicit presence. +/// It can be useful for testing explicit-implicit presence interop behaviour. +struct Proto2NofieldpresenceUnittest_ExplicitForeignMessage: 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 c: Int32 { + get {return _c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {return self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "proto2_nofieldpresence_unittest" @@ -1089,3 +1112,39 @@ extension Proto2NofieldpresenceUnittest_ForeignMessage: SwiftProtobuf.Message, S return true } } + +extension Proto2NofieldpresenceUnittest_ExplicitForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ExplicitForeignMessage" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "c"), + ] + + mutating func decodeMessage(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._c) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // 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 func ==(lhs: Proto2NofieldpresenceUnittest_ExplicitForeignMessage, rhs: Proto2NofieldpresenceUnittest_ExplicitForeignMessage) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Sources/Conformance/conformance.pb.swift b/Sources/Conformance/conformance.pb.swift index 341e78995..c58ddc190 100644 --- a/Sources/Conformance/conformance.pb.swift +++ b/Sources/Conformance/conformance.pb.swift @@ -142,6 +142,27 @@ enum Conformance_TestCategory: SwiftProtobuf.Enum, Swift.CaseIterable { } +/// Meant to encapsulate all types of tests: successes, skips, failures, etc. +/// Therefore, this may or may not have a failure message. Failure messages +/// may be truncated for our failure lists. +struct Conformance_TestStatus: 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 name: String = String() + + var failureMessage: String = String() + + /// What an actual test name matched to in a failure list. Can be wildcarded or + /// an exact match without wildcards. + var matchedName: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + /// The conformance runner will request a list of failures as the first request. /// This will be known by message_type == "conformance.FailureSet", a conformance /// test should return a serialized FailureSet in protobuf_payload. @@ -150,7 +171,7 @@ struct Conformance_FailureSet: Sendable { // `Message` and `Message+*Additions` files in the SwiftProtobuf library for // methods supported on all messages. - var failure: [String] = [] + var test: [Conformance_TestStatus] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -441,10 +462,54 @@ extension Conformance_TestCategory: SwiftProtobuf._ProtoNameProviding { ] } +extension Conformance_TestStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestStatus" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "name"), + 2: .standard(proto: "failure_message"), + 3: .standard(proto: "matched_name"), + ] + + mutating func decodeMessage(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.decodeSingularStringField(value: &self.name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.failureMessage) }() + case 3: try { try decoder.decodeSingularStringField(value: &self.matchedName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.failureMessage.isEmpty { + try visitor.visitSingularStringField(value: self.failureMessage, fieldNumber: 2) + } + if !self.matchedName.isEmpty { + try visitor.visitSingularStringField(value: self.matchedName, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Conformance_TestStatus, rhs: Conformance_TestStatus) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.failureMessage != rhs.failureMessage {return false} + if lhs.matchedName != rhs.matchedName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FailureSet" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "failure"), + 2: .same(proto: "test"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -453,21 +518,21 @@ extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageI // 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.decodeRepeatedStringField(value: &self.failure) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.test) }() default: break } } } func traverse(visitor: inout V) throws { - if !self.failure.isEmpty { - try visitor.visitRepeatedStringField(value: self.failure, fieldNumber: 1) + if !self.test.isEmpty { + try visitor.visitRepeatedMessageField(value: self.test, fieldNumber: 2) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Conformance_FailureSet, rhs: Conformance_FailureSet) -> Bool { - if lhs.failure != rhs.failure {return false} + if lhs.test != rhs.test {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true }