nodiscard ChipError Batch project-chip#9: inet, messaging, system (project-chip#41867)

gmarcosb · bzbarsky-apple · web-flow · commit 7ccaa37acfa7 · 2025-11-12T14:41:32.000Z
* Batch project-chip#9 nodiscard errors: inet, messaging, system * Inadvertent change * Update src/messaging/ExchangeMgr.cpp Co-authored-by: Boris Zbarsky <bzbarsky@apple.com> --------- Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>
diff --git a/src/inet/TCPEndPoint.cpp b/src/inet/TCPEndPoint.cpp
@@ -150,7 +150,7 @@ void TCPEndPoint::Shutdown()
     if (mState == State::kConnected)
     {
         mState = State::kSendShutdown;
-        DriveSending();
+        TEMPORARY_RETURN_IGNORED DriveSending();
     }
 
     // Otherwise, if the peer has already closed their end of the connection,
@@ -215,8 +215,8 @@ void TCPEndPoint::SetIdleTimeout(uint32_t timeoutMS)
 
     if (!isIdleTimerRunning && mIdleTimeout)
     {
-        GetSystemLayer().StartTimer(System::Clock::Milliseconds32(INET_TCP_IDLE_CHECK_INTERVAL), HandleIdleTimer,
-                                    &GetEndPointManager());
+        TEMPORARY_RETURN_IGNORED GetSystemLayer().StartTimer(System::Clock::Milliseconds32(INET_TCP_IDLE_CHECK_INTERVAL),
+                                                             HandleIdleTimer, &GetEndPointManager());
     }
 }
 
@@ -246,7 +246,8 @@ void TCPEndPoint::HandleIdleTimer(chip::System::Layer * aSystemLayer, void * aAp
 
     if (lTimerRequired)
     {
-        aSystemLayer->StartTimer(System::Clock::Milliseconds32(INET_TCP_IDLE_CHECK_INTERVAL), HandleIdleTimer, &endPointManager);
+        TEMPORARY_RETURN_IGNORED aSystemLayer->StartTimer(System::Clock::Milliseconds32(INET_TCP_IDLE_CHECK_INTERVAL),
+                                                          HandleIdleTimer, &endPointManager);
     }
 }
 
@@ -284,7 +285,8 @@ void TCPEndPoint::StartConnectTimerIfSet()
 {
     if (mConnectTimeoutMsecs > 0)
     {
-        GetSystemLayer().StartTimer(System::Clock::Milliseconds32(mConnectTimeoutMsecs), TCPConnectTimeoutHandler, this);
+        TEMPORARY_RETURN_IGNORED GetSystemLayer().StartTimer(System::Clock::Milliseconds32(mConnectTimeoutMsecs),
+                                                             TCPConnectTimeoutHandler, this);
     }
 }
 
@@ -337,7 +339,7 @@ void TCPEndPoint::DriveReceiving(const TCPEndPointHandle & handle)
             DoClose(err, false);
             return;
         }
-        AckReceive(ackLength);
+        TEMPORARY_RETURN_IGNORED AckReceive(ackLength);
     }
 
     // If the connection is closing, and the receive queue is now empty, call DoClose() to complete
@@ -447,7 +449,7 @@ void TCPEndPoint::DoClose(CHIP_ERROR err, bool suppressCallback)
 
 void TCPEndPoint::ScheduleNextTCPUserTimeoutPoll(uint32_t aTimeOut)
 {
-    GetSystemLayer().StartTimer(System::Clock::Milliseconds32(aTimeOut), TCPUserTimeoutHandler, this);
+    TEMPORARY_RETURN_IGNORED GetSystemLayer().StartTimer(System::Clock::Milliseconds32(aTimeOut), TCPUserTimeoutHandler, this);
 }
 
 void TCPEndPoint::StartTCPUserTimeoutTimer()
diff --git a/src/inet/TCPEndPointImplSockets.cpp b/src/inet/TCPEndPointImplSockets.cpp
@@ -618,7 +618,7 @@ void TCPEndPointImplSockets::DoCloseImpl(CHIP_ERROR err, State oldState)
                 }
             }
 
-            static_cast<System::LayerSockets &>(GetSystemLayer()).StopWatchingSocket(&mWatch);
+            TEMPORARY_RETURN_IGNORED static_cast<System::LayerSockets &>(GetSystemLayer()).StopWatchingSocket(&mWatch);
             close(mSocket);
             mSocket = kInvalidSocketFd;
         }
@@ -741,8 +741,9 @@ CHIP_ERROR TCPEndPointImplSockets::GetSocket(IPAddressType addrType)
             mSocket = kInvalidSocketFd;
         });
         ReturnErrorOnFailure(static_cast<System::LayerSockets &>(GetSystemLayer()).StartWatchingSocket(mSocket, &mWatch));
-        auto watchCleanup = ScopeExit([&]() { static_cast<System::LayerSockets &>(GetSystemLayer()).StopWatchingSocket(&mWatch); });
-        mAddrType         = addrType;
+        auto watchCleanup = ScopeExit(
+            [&]() { TEMPORARY_RETURN_IGNORED static_cast<System::LayerSockets &>(GetSystemLayer()).StopWatchingSocket(&mWatch); });
+        mAddrType = addrType;
 
         // If creating an IPv6 socket, tell the kernel that it will be IPv6 only.  This makes it
         // posible to bind two sockets to the same port, one for IPv4 and one for IPv6.
@@ -834,7 +835,7 @@ void TCPEndPointImplSockets::HandlePendingIO(System::SocketEvents events)
         // writing, drive outbound data into the connection.
         if (IsConnected() && !mSendQueue.IsNull() && events.Has(System::SocketEventFlags::kWrite))
         {
-            DriveSending();
+            TEMPORARY_RETURN_IGNORED DriveSending();
         }
 
         // If in a state were receiving is allowed, and the app is ready to receive data, and data is ready
diff --git a/src/inet/UDPEndPointImplSockets.cpp b/src/inet/UDPEndPointImplSockets.cpp
@@ -430,7 +430,7 @@ void UDPEndPointImplSockets::CloseImpl()
 {
     if (mSocket != kInvalidSocketFd)
     {
-        static_cast<System::LayerSockets *>(&GetSystemLayer())->StopWatchingSocket(&mWatch);
+        TEMPORARY_RETURN_IGNORED static_cast<System::LayerSockets *>(&GetSystemLayer())->StopWatchingSocket(&mWatch);
         close(mSocket);
         mSocket = kInvalidSocketFd;
     }
@@ -848,7 +848,7 @@ CHIP_ERROR UDPEndPointImplSockets::IPv6JoinLeaveMulticastGroupImpl(InterfaceId a
             interfaceFound = true;
 
             char ifName[InterfaceId::kMaxIfNameLength];
-            interfaceIt.GetInterfaceName(ifName, sizeof(ifName));
+            TEMPORARY_RETURN_IGNORED interfaceIt.GetInterfaceName(ifName, sizeof(ifName));
 
             // Ignore errors here, except for logging, because we expect some of
             // these interfaces to not work, and some (e.g. loopback) to always
diff --git a/src/inet/tests/inet-layer-test-tool.cpp b/src/inet/tests/inet-layer-test-tool.cpp
@@ -526,12 +526,12 @@ void HandleTCPConnectionComplete(const TCPEndPointHandle & aEndPoint, CHIP_ERROR
         printf("TCP connection established to %s:%u\n", lPeerAddressBuffer, lPeerPort);
 
         if (sTCPIPEndPoint->PendingReceiveLength() == 0)
-            sTCPIPEndPoint->SetReceivedDataForTesting(nullptr);
+            TEMPORARY_RETURN_IGNORED sTCPIPEndPoint->SetReceivedDataForTesting(nullptr);
 
-        sTCPIPEndPoint->DisableReceive();
-        sTCPIPEndPoint->EnableKeepAlive(10, 100);
-        sTCPIPEndPoint->DisableKeepAlive();
-        sTCPIPEndPoint->EnableReceive();
+        TEMPORARY_RETURN_IGNORED sTCPIPEndPoint->DisableReceive();
+        TEMPORARY_RETURN_IGNORED sTCPIPEndPoint->EnableKeepAlive(10, 100);
+        TEMPORARY_RETURN_IGNORED sTCPIPEndPoint->DisableKeepAlive();
+        TEMPORARY_RETURN_IGNORED sTCPIPEndPoint->EnableReceive();
 
         DriveSend();
     }
@@ -541,7 +541,8 @@ void HandleTCPConnectionComplete(const TCPEndPointHandle & aEndPoint, CHIP_ERROR
 
         gSendIntervalExpired = false;
         gSystemLayer.CancelTimer(Common::HandleSendTimerComplete, nullptr);
-        gSystemLayer.StartTimer(System::Clock::Milliseconds32(gSendIntervalMs), Common::HandleSendTimerComplete, nullptr);
+        TEMPORARY_RETURN_IGNORED gSystemLayer.StartTimer(System::Clock::Milliseconds32(gSendIntervalMs),
+                                                         Common::HandleSendTimerComplete, nullptr);
 
         SetStatusFailed(sTestState.mStatus);
     }
@@ -767,7 +768,8 @@ void DriveSend()
     else
     {
         gSendIntervalExpired = false;
-        gSystemLayer.StartTimer(System::Clock::Milliseconds32(gSendIntervalMs), Common::HandleSendTimerComplete, nullptr);
+        TEMPORARY_RETURN_IGNORED gSystemLayer.StartTimer(System::Clock::Milliseconds32(gSendIntervalMs),
+                                                         Common::HandleSendTimerComplete, nullptr);
 
         if (sTestState.mStats.mTransmit.mActual < sTestState.mStats.mTransmit.mExpected)
         {
diff --git a/src/messaging/ExchangeContext.cpp b/src/messaging/ExchangeContext.cpp
@@ -234,7 +234,7 @@ void ExchangeContext::DoClose(bool clearRetransTable)
     // it is done with the exchange context and the message layer sets all callbacks to NULL and does not send anything
     // received on the exchange context up to higher layers.  At this point, the message layer needs to handle the
     // remaining work to be done on that exchange, (e.g. send all pending acks) before truly cleaning it up.
-    FlushAcks();
+    TEMPORARY_RETURN_IGNORED FlushAcks();
 
     // In case the protocol wants a harder release of the EC right away, such as calling Abort(), exchange
     // needs to clear the MRP retransmission table immediately.
@@ -542,7 +542,7 @@ CHIP_ERROR ExchangeContext::HandleMessage(uint32_t messageCounter, const Payload
             if (payloadHeader.NeedsAck())
             {
                 // An acknowledgment needs to be sent back to the peer for this message on this exchange,
-                HandleNeedsAck(messageCounter, msgFlags);
+                TEMPORARY_RETURN_IGNORED HandleNeedsAck(messageCounter, msgFlags);
             }
         }
 
diff --git a/src/messaging/ExchangeMgr.cpp b/src/messaging/ExchangeMgr.cpp
@@ -282,7 +282,8 @@ void ExchangeManager::OnMessageReceived(const PacketHeader & packetHeader, const
                               ChipLogValueExchange(ec), ec->GetDelegate());
 
                 // Matched ExchangeContext; send to message handler.
-                ec->HandleMessage(packetHeader.GetMessageCounter(), payloadHeader, msgFlags, std::move(msgBuf));
+                TEMPORARY_RETURN_IGNORED ec->HandleMessage(packetHeader.GetMessageCounter(), payloadHeader, msgFlags,
+                                                           std::move(msgBuf));
                 found = true;
                 return Loop::Break;
             }
diff --git a/src/messaging/ReliableMessageMgr.cpp b/src/messaging/ReliableMessageMgr.cpp
@@ -157,7 +157,7 @@ void ReliableMessageMgr::ExecuteActions()
 #if defined(RMP_TICKLESS_DEBUG)
                 ChipLogDetail(ExchangeManager, "ReliableMessageMgr::ExecuteActions sending ACK %p", rc);
 #endif
-                rc->SendStandaloneAckMessage();
+                TEMPORARY_RETURN_IGNORED rc->SendStandaloneAckMessage();
             }
         }
     });
@@ -226,7 +226,7 @@ void ReliableMessageMgr::ExecuteActions()
                         Transport::GetSessionTypeString(session), fabricIndex, ChipLogValueX64(destination));
         MATTER_LOG_METRIC(Tracing::kMetricDeviceRMPRetryCount, entry->sendCount);
 
-        SendFromRetransTable(entry);
+        TEMPORARY_RETURN_IGNORED SendFromRetransTable(entry);
 
         return Loop::Continue;
     });
@@ -476,7 +476,7 @@ void ReliableMessageMgr::StartTimer()
                       "ms (in 0x" ChipLogFormatX64 "ms)",
                       ChipLogValueX64(now.count()), ChipLogValueX64(nextWakeTime.count()), ChipLogValueX64(nextWakeDelay.count()));
 #endif
-        VerifyOrDie(mSystemLayer->StartTimer(nextWakeDelay, Timeout, this) == CHIP_NO_ERROR);
+        SuccessOrDie(mSystemLayer->StartTimer(nextWakeDelay, Timeout, this));
     }
     else
     {
diff --git a/src/messaging/tests/echo/echo_requester.cpp b/src/messaging/tests/echo/echo_requester.cpp
@@ -123,12 +123,12 @@ void EchoTimerHandler(chip::System::Layer * systemLayer, void * appState)
         if (err != CHIP_NO_ERROR)
         {
             printf("Send request failed: %s\n", chip::ErrorStr(err));
-            chip::DeviceLayer::PlatformMgr().StopEventLoopTask();
+            TEMPORARY_RETURN_IGNORED chip::DeviceLayer::PlatformMgr().StopEventLoopTask();
         }
     }
     else
     {
-        chip::DeviceLayer::PlatformMgr().StopEventLoopTask();
+        TEMPORARY_RETURN_IGNORED chip::DeviceLayer::PlatformMgr().StopEventLoopTask();
     }
 }
 
@@ -230,7 +230,7 @@ void CloseConnection()
 
 void HandleConnectionAttemptComplete(chip::Transport::ActiveTCPConnectionHandle & conn, CHIP_ERROR err)
 {
-    chip::DeviceLayer::PlatformMgr().StopEventLoopTask();
+    TEMPORARY_RETURN_IGNORED chip::DeviceLayer::PlatformMgr().StopEventLoopTask();
 
     if (err != CHIP_NO_ERROR || conn != gActiveTCPConnState)
     {
diff --git a/src/system/TLVPacketBufferBackingStore.h b/src/system/TLVPacketBufferBackingStore.h
@@ -128,7 +128,7 @@ class DLL_EXPORT PacketBufferTLVWriter : public chip::TLV::TLVWriter
     void Init(chip::System::PacketBufferHandle && buffer, bool useChainedBuffers = false)
     {
         mBackingStore.Init(std::move(buffer), useChainedBuffers);
-        chip::TLV::TLVWriter::Init(mBackingStore);
+        TEMPORARY_RETURN_IGNORED chip::TLV::TLVWriter::Init(mBackingStore);
     }
     /**
      * Finish the writing of a TLV encoding and release ownership of the underlying PacketBuffer.
diff --git a/src/system/WakeEvent.cpp b/src/system/WakeEvent.cpp
@@ -88,7 +88,7 @@ CHIP_ERROR WakeEvent::Open(LayerSockets & systemLayer)
 
 void WakeEvent::Close(LayerSockets & systemLayer)
 {
-    systemLayer.StopWatchingSocket(&mReadWatch);
+    TEMPORARY_RETURN_IGNORED systemLayer.StopWatchingSocket(&mReadWatch);
     VerifyOrDie(::close(mReadFD) == 0);
     VerifyOrDie(::close(mWriteFD) == 0);
     mReadFD  = -1;

Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ void TCPEndPoint::Shutdown()`
`150`	`150`	`if (mState == State::kConnected)`
`151`	`151`	`{`
`152`	`152`	`mState = State::kSendShutdown;`
`153`		`- DriveSending();`
	`153`	`+ TEMPORARY_RETURN_IGNORED DriveSending();`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`// Otherwise, if the peer has already closed their end of the connection,`
`@@ -215,8 +215,8 @@ void TCPEndPoint::SetIdleTimeout(uint32_t timeoutMS)`
`215`	`215`
`216`	`216`	`if (!isIdleTimerRunning && mIdleTimeout)`
`217`	`217`	`{`
`218`		`- GetSystemLayer().StartTimer(System::Clock::Milliseconds32(INET_TCP_IDLE_CHECK_INTERVAL), HandleIdleTimer,`
`219`		`- &GetEndPointManager());`
	`218`	`+ TEMPORARY_RETURN_IGNORED GetSystemLayer().StartTimer(System::Clock::Milliseconds32(INET_TCP_IDLE_CHECK_INTERVAL),`
	`219`	`+ HandleIdleTimer, &GetEndPointManager());`
`220`	`220`	`}`
`221`	`221`	`}`
`222`	`222`
`@@ -246,7 +246,8 @@ void TCPEndPoint::HandleIdleTimer(chip::System::Layer * aSystemLayer, void * aAp`
`246`	`246`
`247`	`247`	`if (lTimerRequired)`
`248`	`248`	`{`
`249`		`- aSystemLayer->StartTimer(System::Clock::Milliseconds32(INET_TCP_IDLE_CHECK_INTERVAL), HandleIdleTimer, &endPointManager);`
	`249`	`+ TEMPORARY_RETURN_IGNORED aSystemLayer->StartTimer(System::Clock::Milliseconds32(INET_TCP_IDLE_CHECK_INTERVAL),`
	`250`	`+ HandleIdleTimer, &endPointManager);`
`250`	`251`	`}`
`251`	`252`	`}`
`252`	`253`
`@@ -284,7 +285,8 @@ void TCPEndPoint::StartConnectTimerIfSet()`
`284`	`285`	`{`
`285`	`286`	`if (mConnectTimeoutMsecs > 0)`
`286`	`287`	`{`
`287`		`- GetSystemLayer().StartTimer(System::Clock::Milliseconds32(mConnectTimeoutMsecs), TCPConnectTimeoutHandler, this);`
	`288`	`+ TEMPORARY_RETURN_IGNORED GetSystemLayer().StartTimer(System::Clock::Milliseconds32(mConnectTimeoutMsecs),`
	`289`	`+ TCPConnectTimeoutHandler, this);`
`288`	`290`	`}`
`289`	`291`	`}`
`290`	`292`
`@@ -337,7 +339,7 @@ void TCPEndPoint::DriveReceiving(const TCPEndPointHandle & handle)`
`337`	`339`	`DoClose(err, false);`
`338`	`340`	`return;`
`339`	`341`	`}`
`340`		`- AckReceive(ackLength);`
	`342`	`+ TEMPORARY_RETURN_IGNORED AckReceive(ackLength);`
`341`	`343`	`}`
`342`	`344`
`343`	`345`	`// If the connection is closing, and the receive queue is now empty, call DoClose() to complete`
`@@ -447,7 +449,7 @@ void TCPEndPoint::DoClose(CHIP_ERROR err, bool suppressCallback)`
`447`	`449`
`448`	`450`	`void TCPEndPoint::ScheduleNextTCPUserTimeoutPoll(uint32_t aTimeOut)`
`449`	`451`	`{`
`450`		`- GetSystemLayer().StartTimer(System::Clock::Milliseconds32(aTimeOut), TCPUserTimeoutHandler, this);`
	`452`	`+ TEMPORARY_RETURN_IGNORED GetSystemLayer().StartTimer(System::Clock::Milliseconds32(aTimeOut), TCPUserTimeoutHandler, this);`
`451`	`453`	`}`
`452`	`454`
`453`	`455`	`void TCPEndPoint::StartTCPUserTimeoutTimer()`
Original file line number	Diff line number	Diff line change
`@@ -618,7 +618,7 @@ void TCPEndPointImplSockets::DoCloseImpl(CHIP_ERROR err, State oldState)`
`618`	`618`	`}`
`619`	`619`	`}`
`620`	`620`
`621`		`- static_cast<System::LayerSockets &>(GetSystemLayer()).StopWatchingSocket(&mWatch);`
	`621`	`+ TEMPORARY_RETURN_IGNORED static_cast<System::LayerSockets &>(GetSystemLayer()).StopWatchingSocket(&mWatch);`
`622`	`622`	`close(mSocket);`
`623`	`623`	`mSocket = kInvalidSocketFd;`
`624`	`624`	`}`
`@@ -741,8 +741,9 @@ CHIP_ERROR TCPEndPointImplSockets::GetSocket(IPAddressType addrType)`
`741`	`741`	`mSocket = kInvalidSocketFd;`
`742`	`742`	`});`
`743`	`743`	`ReturnErrorOnFailure(static_cast<System::LayerSockets &>(GetSystemLayer()).StartWatchingSocket(mSocket, &mWatch));`
`744`		`- auto watchCleanup = ScopeExit([&]() { static_cast<System::LayerSockets &>(GetSystemLayer()).StopWatchingSocket(&mWatch); });`
`745`		`- mAddrType = addrType;`
	`744`	`+ auto watchCleanup = ScopeExit(`
	`745`	`+ [&]() { TEMPORARY_RETURN_IGNORED static_cast<System::LayerSockets &>(GetSystemLayer()).StopWatchingSocket(&mWatch); });`
	`746`	`+ mAddrType = addrType;`
`746`	`747`
`747`	`748`	`// If creating an IPv6 socket, tell the kernel that it will be IPv6 only. This makes it`
`748`	`749`	`// posible to bind two sockets to the same port, one for IPv4 and one for IPv6.`
`@@ -834,7 +835,7 @@ void TCPEndPointImplSockets::HandlePendingIO(System::SocketEvents events)`
`834`	`835`	`// writing, drive outbound data into the connection.`
`835`	`836`	`if (IsConnected() && !mSendQueue.IsNull() && events.Has(System::SocketEventFlags::kWrite))`
`836`	`837`	`{`
`837`		`- DriveSending();`
	`838`	`+ TEMPORARY_RETURN_IGNORED DriveSending();`
`838`	`839`	`}`
`839`	`840`
`840`	`841`	`// If in a state were receiving is allowed, and the app is ready to receive data, and data is ready`
Original file line number	Diff line number	Diff line change
`@@ -430,7 +430,7 @@ void UDPEndPointImplSockets::CloseImpl()`
`430`	`430`	`{`
`431`	`431`	`if (mSocket != kInvalidSocketFd)`
`432`	`432`	`{`
`433`		`- static_cast<System::LayerSockets *>(&GetSystemLayer())->StopWatchingSocket(&mWatch);`
	`433`	`+ TEMPORARY_RETURN_IGNORED static_cast<System::LayerSockets *>(&GetSystemLayer())->StopWatchingSocket(&mWatch);`
`434`	`434`	`close(mSocket);`
`435`	`435`	`mSocket = kInvalidSocketFd;`
`436`	`436`	`}`
`@@ -848,7 +848,7 @@ CHIP_ERROR UDPEndPointImplSockets::IPv6JoinLeaveMulticastGroupImpl(InterfaceId a`
`848`	`848`	`interfaceFound = true;`
`849`	`849`
`850`	`850`	`char ifName[InterfaceId::kMaxIfNameLength];`
`851`		`- interfaceIt.GetInterfaceName(ifName, sizeof(ifName));`
	`851`	`+ TEMPORARY_RETURN_IGNORED interfaceIt.GetInterfaceName(ifName, sizeof(ifName));`
`852`	`852`
`853`	`853`	`// Ignore errors here, except for logging, because we expect some of`
`854`	`854`	`// these interfaces to not work, and some (e.g. loopback) to always`
Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,7 @@ void ExchangeContext::DoClose(bool clearRetransTable)`
`234`	`234`	`// it is done with the exchange context and the message layer sets all callbacks to NULL and does not send anything`
`235`	`235`	`// received on the exchange context up to higher layers. At this point, the message layer needs to handle the`
`236`	`236`	`// remaining work to be done on that exchange, (e.g. send all pending acks) before truly cleaning it up.`
`237`		`- FlushAcks();`
	`237`	`+ TEMPORARY_RETURN_IGNORED FlushAcks();`
`238`	`238`
`239`	`239`	`// In case the protocol wants a harder release of the EC right away, such as calling Abort(), exchange`
`240`	`240`	`// needs to clear the MRP retransmission table immediately.`
`@@ -542,7 +542,7 @@ CHIP_ERROR ExchangeContext::HandleMessage(uint32_t messageCounter, const Payload`
`542`	`542`	`if (payloadHeader.NeedsAck())`
`543`	`543`	`{`
`544`	`544`	`// An acknowledgment needs to be sent back to the peer for this message on this exchange,`
`545`		`- HandleNeedsAck(messageCounter, msgFlags);`
	`545`	`+ TEMPORARY_RETURN_IGNORED HandleNeedsAck(messageCounter, msgFlags);`
`546`	`546`	`}`
`547`	`547`	`}`
`548`	`548`
Original file line number	Diff line number	Diff line change
`@@ -282,7 +282,8 @@ void ExchangeManager::OnMessageReceived(const PacketHeader & packetHeader, const`
`282`	`282`	`ChipLogValueExchange(ec), ec->GetDelegate());`
`283`	`283`
`284`	`284`	`// Matched ExchangeContext; send to message handler.`
`285`		`- ec->HandleMessage(packetHeader.GetMessageCounter(), payloadHeader, msgFlags, std::move(msgBuf));`
	`285`	`+ TEMPORARY_RETURN_IGNORED ec->HandleMessage(packetHeader.GetMessageCounter(), payloadHeader, msgFlags,`
	`286`	`+ std::move(msgBuf));`
`286`	`287`	`found = true;`
`287`	`288`	`return Loop::Break;`
`288`	`289`	`}`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ void ReliableMessageMgr::ExecuteActions()`
`157`	`157`	`#if defined(RMP_TICKLESS_DEBUG)`
`158`	`158`	`ChipLogDetail(ExchangeManager, "ReliableMessageMgr::ExecuteActions sending ACK %p", rc);`
`159`	`159`	`#endif`
`160`		`- rc->SendStandaloneAckMessage();`
	`160`	`+ TEMPORARY_RETURN_IGNORED rc->SendStandaloneAckMessage();`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`	`});`
`@@ -226,7 +226,7 @@ void ReliableMessageMgr::ExecuteActions()`
`226`	`226`	`Transport::GetSessionTypeString(session), fabricIndex, ChipLogValueX64(destination));`
`227`	`227`	`MATTER_LOG_METRIC(Tracing::kMetricDeviceRMPRetryCount, entry->sendCount);`
`228`	`228`
`229`		`- SendFromRetransTable(entry);`
	`229`	`+ TEMPORARY_RETURN_IGNORED SendFromRetransTable(entry);`
`230`	`230`
`231`	`231`	`return Loop::Continue;`
`232`	`232`	`});`
`@@ -476,7 +476,7 @@ void ReliableMessageMgr::StartTimer()`
`476`	`476`	`"ms (in 0x" ChipLogFormatX64 "ms)",`
`477`	`477`	`ChipLogValueX64(now.count()), ChipLogValueX64(nextWakeTime.count()), ChipLogValueX64(nextWakeDelay.count()));`
`478`	`478`	`#endif`
`479`		`- VerifyOrDie(mSystemLayer->StartTimer(nextWakeDelay, Timeout, this) == CHIP_NO_ERROR);`
	`479`	`+ SuccessOrDie(mSystemLayer->StartTimer(nextWakeDelay, Timeout, this));`
`480`	`480`	`}`
`481`	`481`	`else`
`482`	`482`	`{`
Original file line number	Diff line number	Diff line change
`@@ -123,12 +123,12 @@ void EchoTimerHandler(chip::System::Layer * systemLayer, void * appState)`
`123`	`123`	`if (err != CHIP_NO_ERROR)`
`124`	`124`	`{`
`125`	`125`	`printf("Send request failed: %s\n", chip::ErrorStr(err));`
`126`		`- chip::DeviceLayer::PlatformMgr().StopEventLoopTask();`
	`126`	`+ TEMPORARY_RETURN_IGNORED chip::DeviceLayer::PlatformMgr().StopEventLoopTask();`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`	`else`
`130`	`130`	`{`
`131`		`- chip::DeviceLayer::PlatformMgr().StopEventLoopTask();`
	`131`	`+ TEMPORARY_RETURN_IGNORED chip::DeviceLayer::PlatformMgr().StopEventLoopTask();`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
`@@ -230,7 +230,7 @@ void CloseConnection()`
`230`	`230`
`231`	`231`	`void HandleConnectionAttemptComplete(chip::Transport::ActiveTCPConnectionHandle & conn, CHIP_ERROR err)`
`232`	`232`	`{`
`233`		`- chip::DeviceLayer::PlatformMgr().StopEventLoopTask();`
	`233`	`+ TEMPORARY_RETURN_IGNORED chip::DeviceLayer::PlatformMgr().StopEventLoopTask();`
`234`	`234`
`235`	`235`	`if (err != CHIP_NO_ERROR \|\| conn != gActiveTCPConnState)`
`236`	`236`	`{`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ class DLL_EXPORT PacketBufferTLVWriter : public chip::TLV::TLVWriter`
`128`	`128`	`void Init(chip::System::PacketBufferHandle && buffer, bool useChainedBuffers = false)`
`129`	`129`	`{`
`130`	`130`	`mBackingStore.Init(std::move(buffer), useChainedBuffers);`
`131`		`- chip::TLV::TLVWriter::Init(mBackingStore);`
	`131`	`+ TEMPORARY_RETURN_IGNORED chip::TLV::TLVWriter::Init(mBackingStore);`
`132`	`132`	`}`
`133`	`133`	`/**`
`134`	`134`	`* Finish the writing of a TLV encoding and release ownership of the underlying PacketBuffer.`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ CHIP_ERROR WakeEvent::Open(LayerSockets & systemLayer)`
`88`	`88`
`89`	`89`	`void WakeEvent::Close(LayerSockets & systemLayer)`
`90`	`90`	`{`
`91`		`- systemLayer.StopWatchingSocket(&mReadWatch);`
	`91`	`+ TEMPORARY_RETURN_IGNORED systemLayer.StopWatchingSocket(&mReadWatch);`
`92`	`92`	`VerifyOrDie(::close(mReadFD) == 0);`
`93`	`93`	`VerifyOrDie(::close(mWriteFD) == 0);`
`94`	`94`	`mReadFD = -1;`