nodiscard ChipError Batch project-chip#10: lib (project-chip#41868)

gmarcosb · web-flow · commit c80ba35e70cf · 2025-11-12T14:42:53.000Z
* Batch project-chip#10 nodiscard errors: lib * Review suggestions
diff --git a/src/lib/address_resolve/tool.cpp b/src/lib/address_resolve/tool.cpp
@@ -74,7 +74,7 @@ class PrintOutNodeListener : public chip::AddressResolve::NodeListener
 
     AddressResolve::NodeLookupHandle & Handle() { return mSelfHandle; }
 
-    void NotifyDone() { DeviceLayer::PlatformMgr().StopEventLoopTask(); }
+    void NotifyDone() { TEMPORARY_RETURN_IGNORED DeviceLayer::PlatformMgr().StopEventLoopTask(); }
 
 private:
     AddressResolve::NodeLookupHandle mSelfHandle;
@@ -142,14 +142,14 @@ bool Cmd_Node(int argc, const char ** argv)
 extern "C" void StopSignalHandler(int signal)
 {
     // no lint below because StopEventLoopTask is assumed to be async safe.
-    DeviceLayer::PlatformMgr().StopEventLoopTask(); // NOLINT(bugprone-signal-handler)
+    TEMPORARY_RETURN_IGNORED DeviceLayer::PlatformMgr().StopEventLoopTask(); // NOLINT(bugprone-signal-handler)
 }
 
 } // namespace
 
 int main(int argc, const char ** argv)
 {
-    Platform::MemoryInit();
+    TEMPORARY_RETURN_IGNORED Platform::MemoryInit();
 
     signal(SIGTERM, StopSignalHandler);
     signal(SIGINT, StopSignalHandler);
diff --git a/src/lib/core/TLVCircularBuffer.h b/src/lib/core/TLVCircularBuffer.h
@@ -161,7 +161,7 @@ class DLL_EXPORT CircularTLVReader : public TLVReader
      * @param[in]    buf   A pointer to a fully initialized TLVCircularBuffer
      *
      */
-    void Init(TLVCircularBuffer & buf) { TLVReader::Init(buf, buf.DataLength()); }
+    void Init(TLVCircularBuffer & buf) { TEMPORARY_RETURN_IGNORED TLVReader::Init(buf, buf.DataLength()); }
 };
 
 class DLL_EXPORT CircularTLVWriter : public TLVWriter
@@ -182,7 +182,7 @@ class DLL_EXPORT CircularTLVWriter : public TLVWriter
      * @param[in]    buf   A pointer to a fully initialized TLVCircularBuffer
      *
      */
-    void Init(TLVCircularBuffer & buf) { TLVWriter::Init(buf, UINT32_MAX); }
+    void Init(TLVCircularBuffer & buf) { TEMPORARY_RETURN_IGNORED TLVWriter::Init(buf, UINT32_MAX); }
 };
 
 } // namespace TLV
diff --git a/src/lib/core/TLVVectorWriter.cpp b/src/lib/core/TLVVectorWriter.cpp
@@ -34,7 +34,7 @@ constexpr uint32_t kIpv6MtuSize = 1280;
 
 TlvVectorWriter::TlvVectorWriter(std::vector<uint8_t> & buffer) : mVectorBuffer(buffer)
 {
-    Init(mVectorBuffer);
+    TEMPORARY_RETURN_IGNORED Init(mVectorBuffer);
 }
 
 TlvVectorWriter::~TlvVectorWriter() = default;
diff --git a/src/lib/dnssd/Advertiser_ImplMinimalMdns.cpp b/src/lib/dnssd/Advertiser_ImplMinimalMdns.cpp
@@ -369,7 +369,7 @@ CHIP_ERROR AdvertiserMinMdns::Init(chip::Inet::EndPointManager<chip::Inet::UDPEn
 
     if (!mIsInitialized)
     {
-        UpdateCommissionableInstanceName();
+        TEMPORARY_RETURN_IGNORED UpdateCommissionableInstanceName();
     }
 
     // Re-set the server in the response sender in case this has been swapped in the
@@ -554,8 +554,9 @@ CHIP_ERROR AdvertiserMinMdns::Advertise(const OperationalAdvertisingParameters &
             return CHIP_ERROR_NO_MEMORY;
         }
     }
-    MakeServiceSubtype(nameBuffer, sizeof(nameBuffer),
-                       DiscoveryFilter(DiscoveryFilterType::kCompressedFabricId, params.GetPeerId().GetCompressedFabricId()));
+    TEMPORARY_RETURN_IGNORED MakeServiceSubtype(
+        nameBuffer, sizeof(nameBuffer),
+        DiscoveryFilter(DiscoveryFilterType::kCompressedFabricId, params.GetPeerId().GetCompressedFabricId()));
     FullQName compressedFabricIdSubtype = operationalAllocator->AllocateQName(
         nameBuffer, kSubtypeServiceNamePart, kOperationalServiceName, kOperationalProtocol, kLocalDomain);
     VerifyOrReturnError(compressedFabricIdSubtype.nameCount != 0, CHIP_ERROR_NO_MEMORY);
@@ -673,7 +674,8 @@ CHIP_ERROR AdvertiserMinMdns::Advertise(const CommissionAdvertisingParameters &
 
     if (const auto & vendorId = params.GetVendorId(); vendorId.has_value())
     {
-        MakeServiceSubtype(nameBuffer, sizeof(nameBuffer), DiscoveryFilter(DiscoveryFilterType::kVendorId, *vendorId));
+        TEMPORARY_RETURN_IGNORED MakeServiceSubtype(nameBuffer, sizeof(nameBuffer),
+                                                    DiscoveryFilter(DiscoveryFilterType::kVendorId, *vendorId));
         FullQName vendorServiceName =
             allocator->AllocateQName(nameBuffer, kSubtypeServiceNamePart, serviceType, kCommissionProtocol, kLocalDomain);
         VerifyOrReturnError(vendorServiceName.nameCount != 0, CHIP_ERROR_NO_MEMORY);
@@ -690,7 +692,8 @@ CHIP_ERROR AdvertiserMinMdns::Advertise(const CommissionAdvertisingParameters &
 
     if (const auto & deviceType = params.GetDeviceType(); deviceType.has_value())
     {
-        MakeServiceSubtype(nameBuffer, sizeof(nameBuffer), DiscoveryFilter(DiscoveryFilterType::kDeviceType, *deviceType));
+        TEMPORARY_RETURN_IGNORED MakeServiceSubtype(nameBuffer, sizeof(nameBuffer),
+                                                    DiscoveryFilter(DiscoveryFilterType::kDeviceType, *deviceType));
         FullQName vendorServiceName =
             allocator->AllocateQName(nameBuffer, kSubtypeServiceNamePart, serviceType, kCommissionProtocol, kLocalDomain);
         VerifyOrReturnError(vendorServiceName.nameCount != 0, CHIP_ERROR_NO_MEMORY);
@@ -709,8 +712,9 @@ CHIP_ERROR AdvertiserMinMdns::Advertise(const CommissionAdvertisingParameters &
     if (params.GetCommissionAdvertiseMode() == CommssionAdvertiseMode::kCommissionableNode)
     {
         {
-            MakeServiceSubtype(nameBuffer, sizeof(nameBuffer),
-                               DiscoveryFilter(DiscoveryFilterType::kShortDiscriminator, params.GetShortDiscriminator()));
+            TEMPORARY_RETURN_IGNORED MakeServiceSubtype(
+                nameBuffer, sizeof(nameBuffer),
+                DiscoveryFilter(DiscoveryFilterType::kShortDiscriminator, params.GetShortDiscriminator()));
             FullQName shortServiceName =
                 allocator->AllocateQName(nameBuffer, kSubtypeServiceNamePart, serviceType, kCommissionProtocol, kLocalDomain);
             VerifyOrReturnError(shortServiceName.nameCount != 0, CHIP_ERROR_NO_MEMORY);
@@ -726,8 +730,9 @@ CHIP_ERROR AdvertiserMinMdns::Advertise(const CommissionAdvertisingParameters &
         }
 
         {
-            MakeServiceSubtype(nameBuffer, sizeof(nameBuffer),
-                               DiscoveryFilter(DiscoveryFilterType::kLongDiscriminator, params.GetLongDiscriminator()));
+            TEMPORARY_RETURN_IGNORED MakeServiceSubtype(
+                nameBuffer, sizeof(nameBuffer),
+                DiscoveryFilter(DiscoveryFilterType::kLongDiscriminator, params.GetLongDiscriminator()));
             FullQName longServiceName =
                 allocator->AllocateQName(nameBuffer, kSubtypeServiceNamePart, serviceType, kCommissionProtocol, kLocalDomain);
             VerifyOrReturnError(longServiceName.nameCount != 0, CHIP_ERROR_NO_MEMORY);
@@ -743,7 +748,8 @@ CHIP_ERROR AdvertiserMinMdns::Advertise(const CommissionAdvertisingParameters &
 
         if (params.GetCommissioningMode() != CommissioningMode::kDisabled)
         {
-            MakeServiceSubtype(nameBuffer, sizeof(nameBuffer), DiscoveryFilter(DiscoveryFilterType::kCommissioningMode));
+            TEMPORARY_RETURN_IGNORED MakeServiceSubtype(nameBuffer, sizeof(nameBuffer),
+                                                        DiscoveryFilter(DiscoveryFilterType::kCommissioningMode));
             FullQName longServiceName =
                 allocator->AllocateQName(nameBuffer, kSubtypeServiceNamePart, serviceType, kCommissionProtocol, kLocalDomain);
             VerifyOrReturnError(longServiceName.nameCount != 0, CHIP_ERROR_NO_MEMORY);
@@ -792,7 +798,7 @@ FullQName AdvertiserMinMdns::GetOperationalTxtEntries(OperationalQueryAllocator:
     size_t numTxtFields = 0;
 
     struct CommonTxtEntryStorage commonStorage;
-    AddCommonTxtEntries<OperationalAdvertisingParameters>(params, commonStorage, txtFields, numTxtFields);
+    TEMPORARY_RETURN_IGNORED AddCommonTxtEntries<OperationalAdvertisingParameters>(params, commonStorage, txtFields, numTxtFields);
     if (numTxtFields == 0)
     {
         return allocator->AllocateQNameFromArray(mEmptyTextEntries, 1);
@@ -840,7 +846,7 @@ FullQName AdvertiserMinMdns::GetCommissioningTxtEntries(const CommissionAdvertis
         txtFields[numTxtFields++] = txtDeviceName;
     }
     CommonTxtEntryStorage commonStorage;
-    AddCommonTxtEntries<CommissionAdvertisingParameters>(params, commonStorage, txtFields, numTxtFields);
+    TEMPORARY_RETURN_IGNORED AddCommonTxtEntries<CommissionAdvertisingParameters>(params, commonStorage, txtFields, numTxtFields);
 
     // the following sub types only apply to commissionable node advertisements
     char txtDiscriminator[chip::Dnssd::kKeyLongDiscriminatorMaxLength + 3];
diff --git a/src/lib/dnssd/Discovery_ImplPlatform.cpp b/src/lib/dnssd/Discovery_ImplPlatform.cpp
@@ -113,7 +113,7 @@ static void HandleNodeBrowse(void * context, DnssdService * services, size_t ser
         // check whether SRV, TXT and AAAA records were received in DNS responses
         else if (strlen(services[i].mHostName) == 0 || services[i].mTextEntrySize == 0 || !ipAddress.has_value())
         {
-            ChipDnssdResolve(&services[i], services[i].mInterface, HandleNodeResolve, context);
+            TEMPORARY_RETURN_IGNORED ChipDnssdResolve(&services[i], services[i].mInterface, HandleNodeResolve, context);
         }
         else
         {
@@ -391,7 +391,7 @@ void DnssdService::ToDiscoveredOperationalNodeBrowseData(DiscoveredNodeData & no
 {
     nodeData.Set<OperationalNodeBrowseData>();
 
-    ExtractIdFromInstanceName(mName, &nodeData.Get<OperationalNodeBrowseData>().peerId);
+    TEMPORARY_RETURN_IGNORED ExtractIdFromInstanceName(mName, &nodeData.Get<OperationalNodeBrowseData>().peerId);
     nodeData.Get<OperationalNodeBrowseData>().hasZeroTTL = (mTtlSeconds == 0);
 }
 
@@ -437,15 +437,8 @@ CHIP_ERROR DiscoveryImplPlatform::InitImpl()
     VerifyOrReturnError(mState == State::kUninitialized, CHIP_NO_ERROR);
     mState = State::kInitializing;
 
-    CHIP_ERROR err = ChipDnssdInit(HandleDnssdInit, HandleDnssdError, this);
-    if (err != CHIP_NO_ERROR)
-    {
-        mState = State::kUninitialized;
-        return err;
-    }
-    UpdateCommissionableInstanceName();
-
-    return CHIP_NO_ERROR;
+    ReturnErrorOnFailure(ChipDnssdInit(HandleDnssdInit, HandleDnssdError, this), mState = State::kUninitialized);
+    return UpdateCommissionableInstanceName();
 }
 
 void DiscoveryImplPlatform::Shutdown()
@@ -466,15 +459,12 @@ void DiscoveryImplPlatform::HandleDnssdInit(void * context, CHIP_ERROR initError
         // Post an event that will start advertising
         DeviceLayer::ChipDeviceEvent event{ .Type = DeviceLayer::DeviceEventType::kDnssdInitialized };
 
-        CHIP_ERROR error = DeviceLayer::PlatformMgr().PostEvent(&event);
-        if (error != CHIP_NO_ERROR)
-        {
-            ChipLogError(Discovery, "Posting DNS-SD platform initialized event failed with %" CHIP_ERROR_FORMAT, error.Format());
-        }
+        SuccessOrLog(DeviceLayer::PlatformMgr().PostEvent(&event), Discovery,
+                     "Posting DNS-SD platform initialized event failed with");
     }
     else
     {
-        ChipLogError(Discovery, "DNS-SD initialization failed with %" CHIP_ERROR_FORMAT, initError.Format());
+        ChipLogFailure(initError, Discovery, "DNS-SD initialization failed with");
         publisher->mState = State::kUninitialized;
     }
 }
@@ -722,7 +712,7 @@ void DiscoveryImplPlatform::NodeIdResolutionNoLongerNeeded(const PeerId & peerId
 CHIP_ERROR DiscoveryImplPlatform::DiscoverCommissionableNodes(DiscoveryFilter filter, DiscoveryContext & context)
 {
     ReturnErrorOnFailure(InitImpl());
-    StopDiscovery(context);
+    TEMPORARY_RETURN_IGNORED StopDiscovery(context);
 
     if (filter.type == DiscoveryFilterType::kInstanceName)
     {
@@ -768,7 +758,7 @@ CHIP_ERROR DiscoveryImplPlatform::DiscoverCommissionableNodes(DiscoveryFilter fi
 CHIP_ERROR DiscoveryImplPlatform::DiscoverCommissioners(DiscoveryFilter filter, DiscoveryContext & context)
 {
     ReturnErrorOnFailure(InitImpl());
-    StopDiscovery(context);
+    TEMPORARY_RETURN_IGNORED StopDiscovery(context);
 
     if (filter.type == DiscoveryFilterType::kInstanceName)
     {
@@ -812,7 +802,7 @@ CHIP_ERROR DiscoveryImplPlatform::DiscoverCommissioners(DiscoveryFilter filter,
 CHIP_ERROR DiscoveryImplPlatform::DiscoverOperational(DiscoveryFilter filter, DiscoveryContext & context)
 {
     ReturnErrorOnFailure(InitImpl());
-    StopDiscovery(context);
+    TEMPORARY_RETURN_IGNORED StopDiscovery(context);
 
     char serviceName[kMaxOperationalServiceNameSize];
     ReturnErrorOnFailure(MakeServiceTypeName(serviceName, sizeof(serviceName), filter, DiscoveryType::kOperational));
diff --git a/src/lib/dnssd/Resolver_ImplMinimalMdns.cpp b/src/lib/dnssd/Resolver_ImplMinimalMdns.cpp
@@ -509,7 +509,7 @@ void MinMdnsResolver::OnMdnsPacketData(const BytesRange & data, const chip::Inet
 
     AdvancePendingResolverStates();
 
-    ScheduleRetries();
+    TEMPORARY_RETURN_IGNORED ScheduleRetries();
 }
 
 CHIP_ERROR MinMdnsResolver::Init(chip::Inet::EndPointManager<chip::Inet::UDPEndPoint> * udpEndPointManager)
@@ -785,7 +785,7 @@ CHIP_ERROR MinMdnsResolver::ScheduleRetries()
 
 void MinMdnsResolver::RetryCallback(System::Layer *, void * self)
 {
-    reinterpret_cast<MinMdnsResolver *>(self)->SendAllPendingQueries();
+    TEMPORARY_RETURN_IGNORED reinterpret_cast<MinMdnsResolver *>(self)->SendAllPendingQueries();
 }
 
 MinMdnsResolver gResolver;
diff --git a/src/lib/dnssd/Types.h b/src/lib/dnssd/Types.h
@@ -266,7 +266,8 @@ struct CommissionNodeData : public CommonResolutionData
         if (rotatingIdLen > 0)
         {
             char rotatingIdString[chip::Dnssd::kMaxRotatingIdLen * 2 + 1] = "";
-            Encoding::BytesToUppercaseHexString(rotatingId, rotatingIdLen, rotatingIdString, sizeof(rotatingIdString));
+            TEMPORARY_RETURN_IGNORED Encoding::BytesToUppercaseHexString(rotatingId, rotatingIdLen, rotatingIdString,
+                                                                         sizeof(rotatingIdString));
             ChipLogDetail(Discovery, "\tRotating ID: %s", rotatingIdString);
         }
         if (strlen(deviceName) != 0)
diff --git a/src/lib/dnssd/minimal_mdns/ResponseSender.cpp b/src/lib/dnssd/minimal_mdns/ResponseSender.cpp
@@ -290,13 +290,12 @@ void ResponseSender::AddResponse(const ResourceRecord & record)
 
     if (!mResponseBuilder.HasPacketBuffer())
     {
-        mSendState.SetError(PrepareNewReplyPacket());
+        TEMPORARY_RETURN_IGNORED mSendState.SetError(PrepareNewReplyPacket());
         ReturnOnFailure(mSendState.GetError());
     }
-
     if (!mResponseBuilder.Ok())
     {
-        mSendState.SetError(CHIP_ERROR_INCORRECT_STATE);
+        TEMPORARY_RETURN_IGNORED mSendState.SetError(CHIP_ERROR_INCORRECT_STATE);
         return;
     }
 
@@ -317,7 +316,7 @@ void ResponseSender::AddResponse(const ResourceRecord & record)
         {
             // Very much unexpected: single record addition should fit (our records should not be that big).
             ChipLogError(Discovery, "Failed to add single record to mDNS response.");
-            mSendState.SetError(CHIP_ERROR_INTERNAL);
+            TEMPORARY_RETURN_IGNORED mSendState.SetError(CHIP_ERROR_INTERNAL);
         }
     }
 }
diff --git a/src/lib/dnssd/minimal_mdns/Server.cpp b/src/lib/dnssd/minimal_mdns/Server.cpp
@@ -219,7 +219,7 @@ CHIP_ERROR ServerBase::Listen(chip::Inet::EndPointManager<chip::Inet::UDPEndPoin
         if (err != CHIP_NO_ERROR)
         {
             char interfaceName[chip::Inet::InterfaceId::kMaxIfNameLength];
-            interfaceId.GetInterfaceName(interfaceName, sizeof(interfaceName));
+            TEMPORARY_RETURN_IGNORED interfaceId.GetInterfaceName(interfaceName, sizeof(interfaceName));
 
             // Log only as non-fatal error. Failure to join will mean we reply to unicast queries only.
             ChipLogError(DeviceLayer, "MDNS failed to join multicast group on %s for address type %s: %" CHIP_ERROR_FORMAT,
diff --git a/src/lib/format/protocol_decoder.cpp b/src/lib/format/protocol_decoder.cpp
@@ -576,27 +576,27 @@ void PayloadDecoderBase::NextFromValueRead(PayloadEntry & entry)
     switch (data->type)
     {
     case ItemType::kProtocolClusterId:
-        mReader.Get(mClusterId);
+        TEMPORARY_RETURN_IGNORED mReader.Get(mClusterId);
         mIMContentPosition.ResetToTop();
         mIMContentPosition.Enter(ByTag(ClusterTag(mClusterId)));
         info = mIMContentPosition.Get();
         break;
     case ItemType::kProtocolAttributeId:
-        mReader.Get(mAttributeId);
+        TEMPORARY_RETURN_IGNORED mReader.Get(mAttributeId);
         mIMContentPosition.ResetToTop();
         mIMContentPosition.Enter(ByTag(ClusterTag(mClusterId)));
         mIMContentPosition.Enter(ByTag(AttributeTag(mAttributeId)));
         info = mIMContentPosition.Get();
         break;
     case ItemType::kProtocolCommandId:
-        mReader.Get(mCommandId);
+        TEMPORARY_RETURN_IGNORED mReader.Get(mCommandId);
         mIMContentPosition.ResetToTop();
         mIMContentPosition.Enter(ByTag(ClusterTag(mClusterId)));
         mIMContentPosition.Enter(ByTag(CommandTag(mCommandId)));
         info = mIMContentPosition.Get();
         break;
     case ItemType::kProtocolEventId:
-        mReader.Get(mEventId);
+        TEMPORARY_RETURN_IGNORED mReader.Get(mEventId);
         mIMContentPosition.ResetToTop();
         mIMContentPosition.Enter(ByTag(ClusterTag(mClusterId)));
         mIMContentPosition.Enter(ByTag(EventTag(mEventId)));
diff --git a/src/lib/shell/MainLoopDefault.cpp b/src/lib/shell/MainLoopDefault.cpp
@@ -216,7 +216,7 @@ void Engine::RunMainLoop()
             break;
         }
 #if CONFIG_DEVICE_LAYER
-        DeviceLayer::PlatformMgr().ScheduleWork(ProcessShellLine, reinterpret_cast<intptr_t>(line));
+        TEMPORARY_RETURN_IGNORED DeviceLayer::PlatformMgr().ScheduleWork(ProcessShellLine, reinterpret_cast<intptr_t>(line));
 #else
         ProcessShellLine(reinterpret_cast<intptr_t>(line));
 #endif
diff --git a/src/lib/shell/commands/Dns.cpp b/src/lib/shell/commands/Dns.cpp
diff --git a/src/lib/support/BytesCircularBuffer.cpp b/src/lib/support/BytesCircularBuffer.cpp
diff --git a/src/lib/support/PersistedCounter.h b/src/lib/support/PersistedCounter.h
diff --git a/src/lib/support/tests/ExtraPwTestMacros.h b/src/lib/support/tests/ExtraPwTestMacros.h

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ class PrintOutNodeListener : public chip::AddressResolve::NodeListener`
`74`	`74`
`75`	`75`	`AddressResolve::NodeLookupHandle & Handle() { return mSelfHandle; }`
`76`	`76`
`77`		`- void NotifyDone() { DeviceLayer::PlatformMgr().StopEventLoopTask(); }`
	`77`	`+ void NotifyDone() { TEMPORARY_RETURN_IGNORED DeviceLayer::PlatformMgr().StopEventLoopTask(); }`
`78`	`78`
`79`	`79`	`private:`
`80`	`80`	`AddressResolve::NodeLookupHandle mSelfHandle;`
`@@ -142,14 +142,14 @@ bool Cmd_Node(int argc, const char ** argv)`
`142`	`142`	`extern "C" void StopSignalHandler(int signal)`
`143`	`143`	`{`
`144`	`144`	`// no lint below because StopEventLoopTask is assumed to be async safe.`
`145`		`- DeviceLayer::PlatformMgr().StopEventLoopTask(); // NOLINT(bugprone-signal-handler)`
	`145`	`+ TEMPORARY_RETURN_IGNORED DeviceLayer::PlatformMgr().StopEventLoopTask(); // NOLINT(bugprone-signal-handler)`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`} // namespace`
`149`	`149`
`150`	`150`	`int main(int argc, const char ** argv)`
`151`	`151`	`{`
`152`		`- Platform::MemoryInit();`
	`152`	`+ TEMPORARY_RETURN_IGNORED Platform::MemoryInit();`
`153`	`153`
`154`	`154`	`signal(SIGTERM, StopSignalHandler);`
`155`	`155`	`signal(SIGINT, StopSignalHandler);`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ constexpr uint32_t kIpv6MtuSize = 1280;`
`34`	`34`
`35`	`35`	`TlvVectorWriter::TlvVectorWriter(std::vector<uint8_t> & buffer) : mVectorBuffer(buffer)`
`36`	`36`	`{`
`37`		`- Init(mVectorBuffer);`
	`37`	`+ TEMPORARY_RETURN_IGNORED Init(mVectorBuffer);`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`TlvVectorWriter::~TlvVectorWriter() = default;`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ static void HandleNodeBrowse(void * context, DnssdService * services, size_t ser`
`113`	`113`	`// check whether SRV, TXT and AAAA records were received in DNS responses`
`114`	`114`	`else if (strlen(services[i].mHostName) == 0 \|\| services[i].mTextEntrySize == 0 \|\| !ipAddress.has_value())`
`115`	`115`	`{`
`116`		`- ChipDnssdResolve(&services[i], services[i].mInterface, HandleNodeResolve, context);`
	`116`	`+ TEMPORARY_RETURN_IGNORED ChipDnssdResolve(&services[i], services[i].mInterface, HandleNodeResolve, context);`
`117`	`117`	`}`
`118`	`118`	`else`
`119`	`119`	`{`
`@@ -391,7 +391,7 @@ void DnssdService::ToDiscoveredOperationalNodeBrowseData(DiscoveredNodeData & no`
`391`	`391`	`{`
`392`	`392`	`nodeData.Set<OperationalNodeBrowseData>();`
`393`	`393`
`394`		`- ExtractIdFromInstanceName(mName, &nodeData.Get<OperationalNodeBrowseData>().peerId);`
	`394`	`+ TEMPORARY_RETURN_IGNORED ExtractIdFromInstanceName(mName, &nodeData.Get<OperationalNodeBrowseData>().peerId);`
`395`	`395`	`nodeData.Get<OperationalNodeBrowseData>().hasZeroTTL = (mTtlSeconds == 0);`
`396`	`396`	`}`
`397`	`397`
`@@ -437,15 +437,8 @@ CHIP_ERROR DiscoveryImplPlatform::InitImpl()`
`437`	`437`	`VerifyOrReturnError(mState == State::kUninitialized, CHIP_NO_ERROR);`
`438`	`438`	`mState = State::kInitializing;`
`439`	`439`
`440`		`- CHIP_ERROR err = ChipDnssdInit(HandleDnssdInit, HandleDnssdError, this);`
`441`		`- if (err != CHIP_NO_ERROR)`
`442`		`- {`
`443`		`- mState = State::kUninitialized;`
`444`		`- return err;`
`445`		`- }`
`446`		`- UpdateCommissionableInstanceName();`
`447`		`-`
`448`		`- return CHIP_NO_ERROR;`
	`440`	`+ ReturnErrorOnFailure(ChipDnssdInit(HandleDnssdInit, HandleDnssdError, this), mState = State::kUninitialized);`
	`441`	`+ return UpdateCommissionableInstanceName();`
`449`	`442`	`}`
`450`	`443`
`451`	`444`	`void DiscoveryImplPlatform::Shutdown()`
`@@ -466,15 +459,12 @@ void DiscoveryImplPlatform::HandleDnssdInit(void * context, CHIP_ERROR initError`
`466`	`459`	`// Post an event that will start advertising`
`467`	`460`	`DeviceLayer::ChipDeviceEvent event{ .Type = DeviceLayer::DeviceEventType::kDnssdInitialized };`
`468`	`461`
`469`		`- CHIP_ERROR error = DeviceLayer::PlatformMgr().PostEvent(&event);`
`470`		`- if (error != CHIP_NO_ERROR)`
`471`		`- {`
`472`		`- ChipLogError(Discovery, "Posting DNS-SD platform initialized event failed with %" CHIP_ERROR_FORMAT, error.Format());`
`473`		`- }`
	`462`	`+ SuccessOrLog(DeviceLayer::PlatformMgr().PostEvent(&event), Discovery,`
	`463`	`+ "Posting DNS-SD platform initialized event failed with");`
`474`	`464`	`}`
`475`	`465`	`else`
`476`	`466`	`{`
`477`		`- ChipLogError(Discovery, "DNS-SD initialization failed with %" CHIP_ERROR_FORMAT, initError.Format());`
	`467`	`+ ChipLogFailure(initError, Discovery, "DNS-SD initialization failed with");`
`478`	`468`	`publisher->mState = State::kUninitialized;`
`479`	`469`	`}`
`480`	`470`	`}`
`@@ -722,7 +712,7 @@ void DiscoveryImplPlatform::NodeIdResolutionNoLongerNeeded(const PeerId & peerId`
`722`	`712`	`CHIP_ERROR DiscoveryImplPlatform::DiscoverCommissionableNodes(DiscoveryFilter filter, DiscoveryContext & context)`
`723`	`713`	`{`
`724`	`714`	`ReturnErrorOnFailure(InitImpl());`
`725`		`- StopDiscovery(context);`
	`715`	`+ TEMPORARY_RETURN_IGNORED StopDiscovery(context);`
`726`	`716`
`727`	`717`	`if (filter.type == DiscoveryFilterType::kInstanceName)`
`728`	`718`	`{`
`@@ -768,7 +758,7 @@ CHIP_ERROR DiscoveryImplPlatform::DiscoverCommissionableNodes(DiscoveryFilter fi`
`768`	`758`	`CHIP_ERROR DiscoveryImplPlatform::DiscoverCommissioners(DiscoveryFilter filter, DiscoveryContext & context)`
`769`	`759`	`{`
`770`	`760`	`ReturnErrorOnFailure(InitImpl());`
`771`		`- StopDiscovery(context);`
	`761`	`+ TEMPORARY_RETURN_IGNORED StopDiscovery(context);`
`772`	`762`
`773`	`763`	`if (filter.type == DiscoveryFilterType::kInstanceName)`
`774`	`764`	`{`
`@@ -812,7 +802,7 @@ CHIP_ERROR DiscoveryImplPlatform::DiscoverCommissioners(DiscoveryFilter filter,`
`812`	`802`	`CHIP_ERROR DiscoveryImplPlatform::DiscoverOperational(DiscoveryFilter filter, DiscoveryContext & context)`
`813`	`803`	`{`
`814`	`804`	`ReturnErrorOnFailure(InitImpl());`
`815`		`- StopDiscovery(context);`
	`805`	`+ TEMPORARY_RETURN_IGNORED StopDiscovery(context);`
`816`	`806`
`817`	`807`	`char serviceName[kMaxOperationalServiceNameSize];`
`818`	`808`	`ReturnErrorOnFailure(MakeServiceTypeName(serviceName, sizeof(serviceName), filter, DiscoveryType::kOperational));`
Original file line number	Diff line number	Diff line change
`@@ -509,7 +509,7 @@ void MinMdnsResolver::OnMdnsPacketData(const BytesRange & data, const chip::Inet`
`509`	`509`
`510`	`510`	`AdvancePendingResolverStates();`
`511`	`511`
`512`		`- ScheduleRetries();`
	`512`	`+ TEMPORARY_RETURN_IGNORED ScheduleRetries();`
`513`	`513`	`}`
`514`	`514`
`515`	`515`	`CHIP_ERROR MinMdnsResolver::Init(chip::Inet::EndPointManager<chip::Inet::UDPEndPoint> * udpEndPointManager)`
`@@ -785,7 +785,7 @@ CHIP_ERROR MinMdnsResolver::ScheduleRetries()`
`785`	`785`
`786`	`786`	`void MinMdnsResolver::RetryCallback(System::Layer , void self)`
`787`	`787`	`{`
`788`		`- reinterpret_cast<MinMdnsResolver *>(self)->SendAllPendingQueries();`
	`788`	`+ TEMPORARY_RETURN_IGNORED reinterpret_cast<MinMdnsResolver *>(self)->SendAllPendingQueries();`
`789`	`789`	`}`
`790`	`790`
`791`	`791`	`MinMdnsResolver gResolver;`
Original file line number	Diff line number	Diff line change
`@@ -266,7 +266,8 @@ struct CommissionNodeData : public CommonResolutionData`
`266`	`266`	`if (rotatingIdLen > 0)`
`267`	`267`	`{`
`268`	`268`	`char rotatingIdString[chip::Dnssd::kMaxRotatingIdLen * 2 + 1] = "";`
`269`		`- Encoding::BytesToUppercaseHexString(rotatingId, rotatingIdLen, rotatingIdString, sizeof(rotatingIdString));`
	`269`	`+ TEMPORARY_RETURN_IGNORED Encoding::BytesToUppercaseHexString(rotatingId, rotatingIdLen, rotatingIdString,`
	`270`	`+ sizeof(rotatingIdString));`
`270`	`271`	`ChipLogDetail(Discovery, "\tRotating ID: %s", rotatingIdString);`
`271`	`272`	`}`
`272`	`273`	`if (strlen(deviceName) != 0)`
Original file line number	Diff line number	Diff line change
`@@ -290,13 +290,12 @@ void ResponseSender::AddResponse(const ResourceRecord & record)`
`290`	`290`
`291`	`291`	`if (!mResponseBuilder.HasPacketBuffer())`
`292`	`292`	`{`
`293`		`- mSendState.SetError(PrepareNewReplyPacket());`
	`293`	`+ TEMPORARY_RETURN_IGNORED mSendState.SetError(PrepareNewReplyPacket());`
`294`	`294`	`ReturnOnFailure(mSendState.GetError());`
`295`	`295`	`}`
`296`		`-`
`297`	`296`	`if (!mResponseBuilder.Ok())`
`298`	`297`	`{`
`299`		`- mSendState.SetError(CHIP_ERROR_INCORRECT_STATE);`
	`298`	`+ TEMPORARY_RETURN_IGNORED mSendState.SetError(CHIP_ERROR_INCORRECT_STATE);`
`300`	`299`	`return;`
`301`	`300`	`}`
`302`	`301`
`@@ -317,7 +316,7 @@ void ResponseSender::AddResponse(const ResourceRecord & record)`
`317`	`316`	`{`
`318`	`317`	`// Very much unexpected: single record addition should fit (our records should not be that big).`
`319`	`318`	`ChipLogError(Discovery, "Failed to add single record to mDNS response.");`
`320`		`- mSendState.SetError(CHIP_ERROR_INTERNAL);`
	`319`	`+ TEMPORARY_RETURN_IGNORED mSendState.SetError(CHIP_ERROR_INTERNAL);`
`321`	`320`	`}`
`322`	`321`	`}`
`323`	`322`	`}`
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ CHIP_ERROR ServerBase::Listen(chip::Inet::EndPointManager<chip::Inet::UDPEndPoin`
`219`	`219`	`if (err != CHIP_NO_ERROR)`
`220`	`220`	`{`
`221`	`221`	`char interfaceName[chip::Inet::InterfaceId::kMaxIfNameLength];`
`222`		`- interfaceId.GetInterfaceName(interfaceName, sizeof(interfaceName));`
	`222`	`+ TEMPORARY_RETURN_IGNORED interfaceId.GetInterfaceName(interfaceName, sizeof(interfaceName));`
`223`	`223`
`224`	`224`	`// Log only as non-fatal error. Failure to join will mean we reply to unicast queries only.`
`225`	`225`	`ChipLogError(DeviceLayer, "MDNS failed to join multicast group on %s for address type %s: %" CHIP_ERROR_FORMAT,`