Fix some clang static analyzer warnings

tgoyne · tgoyne · commit 84cc8bc2dba6 · 2023-06-02T09:39:32.000-07:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -6,7 +6,7 @@
 
 ### Fixed
 * <How do the end-user experience this issue? what was the impact?> ([#????](https://github.com/realm/realm-core/issues/????), since v?.?.?)
-* None.
+* Fix some clang static analyzer warnings. None of them were actual bugs ([PR #6675](https://github.com/realm/realm-core/pull/6675)).
 
 ### Breaking changes
 * None.
diff --git a/src/realm/bplustree.cpp b/src/realm/bplustree.cpp
@@ -742,9 +742,9 @@ void BPlusTreeBase::bptree_erase(size_t n, BPlusTreeNode::EraseFunc func)
         ref_type new_root_ref = node->clear_first_bp_node_ref();
         node->destroy_deep();
 
-        auto new_root = create_root_from_ref(new_root_ref);
-
-        replace_root(std::move(new_root));
+        if (auto new_root = create_root_from_ref(new_root_ref)) {
+            replace_root(std::move(new_root));
+        }
         root_size = m_root->get_node_size();
     }
 }
@@ -757,7 +757,7 @@ std::unique_ptr<BPlusTreeNode> BPlusTreeBase::create_root_from_ref(ref_type ref)
 
     if (reuse_root) {
         m_root->init_from_ref(ref);
-        return std::move(m_root);
+        return nullptr;
     }
 
     if (is_leaf) {
diff --git a/src/realm/bplustree.hpp b/src/realm/bplustree.hpp
@@ -172,10 +172,10 @@ class BPlusTreeBase {
 
     void init_from_ref(ref_type ref)
     {
-        auto new_root = create_root_from_ref(ref);
-        new_root->bp_set_parent(m_parent, m_ndx_in_parent);
-
-        m_root = std::move(new_root);
+        if (auto new_root = create_root_from_ref(ref)) {
+            new_root->bp_set_parent(m_parent, m_ndx_in_parent);
+            m_root = std::move(new_root);
+        }
 
         invalidate_leaf_cache();
         m_size = m_root->get_tree_size();
@@ -187,9 +187,10 @@ class BPlusTreeBase {
         if (!ref) {
             return false;
         }
-        auto new_root = create_root_from_ref(ref);
-        new_root->bp_set_parent(m_parent, m_ndx_in_parent);
-        m_root = std::move(new_root);
+        if (auto new_root = create_root_from_ref(ref)) {
+            new_root->bp_set_parent(m_parent, m_ndx_in_parent);
+            m_root = std::move(new_root);
+        }
         invalidate_leaf_cache();
         m_size = m_root->get_tree_size();
         return true;
@@ -374,6 +375,11 @@ class BPlusTree : public BPlusTreeBase {
     REALM_NOINLINE T get_uncached(size_t n) const
     {
         T value;
+#ifdef __clang_analyzer__
+        // Clang's static analyzer can't see that value will always be initialized
+        // inside bptree_access()
+        value = {};
+#endif
 
         auto func = [&value](BPlusTreeNode* node, size_t ndx) {
             LeafNode* leaf = static_cast<LeafNode*>(node);
diff --git a/src/realm/object-store/c_api/realm.cpp b/src/realm/object-store/c_api/realm.cpp
@@ -305,7 +305,8 @@ RLM_API bool realm_remove_table(realm_t* realm, const char* table_name, bool* ta
                                  "Attempt to remove a table that is currently part of the schema");
             }
             (*realm)->read_group().remove_table(table->get_key());
-            *table_deleted = true;
+            if (table_deleted)
+                *table_deleted = true;
         }
         return true;
     });
diff --git a/src/realm/sync/CMakeLists.txt b/src/realm/sync/CMakeLists.txt
@@ -80,8 +80,10 @@ set(NOINST_HEADERS
     noinst/sync_metadata_schema.hpp
 )
 
-set(SYNC_HEADERS ${IMPL_INSTALL_HEADESR}
+set(SYNC_HEADERS
+    ${IMPL_INSTALL_HEADESR}
     ${SYNC_INSTALL_HEADERS}
+    ${SYNC_NETWORK_INSTALL_HEADERS}
     ${NOINST_HEADERS})
 
 add_library(Sync STATIC ${SYNC_SOURCES} ${SYNC_HEADERS})
diff --git a/src/realm/sync/network/network.hpp b/src/realm/sync/network/network.hpp
@@ -1998,7 +1998,7 @@ class Service::PostOper : public PostOperBase {
 public:
     PostOper(std::size_t size, Impl& service, H&& handler)
         : PostOperBase{size, service}
-        , m_handler{std::move(handler)}
+        , m_handler{std::forward<H>(handler)}
     {
     }
     void recycle_and_execute() override final
@@ -2256,7 +2256,7 @@ class Service::BasicStreamOps {
         char* begin = buffer;
         char* end = buffer + size;
         LendersReadOperPtr op = Service::alloc<ReadOper<H>>(stream.lowest_layer().m_read_oper, stream, is_read_some,
-                                                            begin, end, std::move(handler)); // Throws
+                                                            begin, end, std::forward<H>(handler)); // Throws
         stream.lowest_layer().m_desc.initiate_oper(std::move(op));                           // Throws
     }
 
@@ -2265,8 +2265,9 @@ class Service::BasicStreamOps {
     {
         const char* begin = data;
         const char* end = data + size;
-        LendersWriteOperPtr op = Service::alloc<WriteOper<H>>(
-            stream.lowest_layer().m_write_oper, stream, is_write_some, begin, end, std::move(handler)); // Throws
+        LendersWriteOperPtr op =
+            Service::alloc<WriteOper<H>>(stream.lowest_layer().m_write_oper, stream, is_write_some, begin, end,
+                                         std::forward<H>(handler));                                     // Throws
         stream.lowest_layer().m_desc.initiate_oper(std::move(op));                                      // Throws
     }
 
@@ -2278,7 +2279,7 @@ class Service::BasicStreamOps {
         char* end = buffer + size;
         LendersBufferedReadOperPtr op =
             Service::alloc<BufferedReadOper<H>>(stream.lowest_layer().m_read_oper, stream, begin, end, delim, rab,
-                                                std::move(handler)); // Throws
+                                                std::forward<H>(handler)); // Throws
         stream.lowest_layer().m_desc.initiate_oper(std::move(op));   // Throws
     }
 };
@@ -2554,7 +2555,7 @@ class Service::BasicStreamOps<S>::ReadOper : public ReadOperBase {
 public:
     ReadOper(std::size_t size, S& stream, bool is_read_some, char* begin, char* end, H&& handler)
         : ReadOperBase{size, stream, is_read_some, begin, end}
-        , m_handler{std::move(handler)}
+        , m_handler{std::forward<H>(handler)}
     {
     }
     void recycle_and_execute() override final
@@ -2584,7 +2585,7 @@ class Service::BasicStreamOps<S>::WriteOper : public WriteOperBase {
 public:
     WriteOper(std::size_t size, S& stream, bool is_write_some, const char* begin, const char* end, H&& handler)
         : WriteOperBase{size, stream, is_write_some, begin, end}
-        , m_handler{std::move(handler)}
+        , m_handler{std::forward<H>(handler)}
     {
     }
     void recycle_and_execute() override final
@@ -2615,7 +2616,7 @@ class Service::BasicStreamOps<S>::BufferedReadOper : public BufferedReadOperBase
     BufferedReadOper(std::size_t size, S& stream, char* begin, char* end, int delim, ReadAheadBuffer& rab,
                      H&& handler)
         : BufferedReadOperBase{size, stream, begin, end, delim, rab}
-        , m_handler{std::move(handler)}
+        , m_handler{std::forward<H>(handler)}
     {
     }
     void recycle_and_execute() override final
@@ -2703,7 +2704,7 @@ template <class H>
 inline Service::PostOperBase* Service::post_oper_constr(void* addr, std::size_t size, Impl& service, void* cookie)
 {
     H& handler = *static_cast<H*>(cookie);
-    return new (addr) PostOper<H>(size, service, std::move(handler)); // Throws
+    return new (addr) PostOper<H>(size, service, std::forward<H>(handler)); // Throws
 }
 
 inline bool Service::AsyncOper::in_use() const noexcept
@@ -2769,10 +2770,8 @@ inline void Service::AsyncOper::do_recycle_and_execute(bool orphaned, H& handler
     // happens. For that reason, copying and moving of arguments must not
     // happen until we are in a scope (this scope) that catches and deals
     // correctly with such exceptions.
-    do_recycle_and_execute_helper(orphaned, was_recycled, std::move(handler),
+    do_recycle_and_execute_helper(orphaned, was_recycled, std::forward<H>(handler),
                                   std::forward<Args>(args)...); // Throws
-
-    // Removed catch to prevent truncating the stack trace on exception
 }
 
 template <class H, class... Args>
@@ -2805,7 +2804,7 @@ class Resolver::ResolveOper : public Service::ResolveOperBase {
 public:
     ResolveOper(std::size_t size, Resolver& r, Query q, H&& handler)
         : ResolveOperBase{size, r, std::move(q)}
-        , m_handler{std::move(handler)}
+        , m_handler{std::forward<H>(handler)}
     {
     }
     void recycle_and_execute() override final
@@ -2847,7 +2846,7 @@ template <class H>
 void Resolver::async_resolve(Query query, H&& handler)
 {
     Service::LendersResolveOperPtr op = Service::alloc<ResolveOper<H>>(m_resolve_oper, *this, std::move(query),
-                                                                       std::move(handler)); // Throws
+                                                                       std::forward<H>(handler)); // Throws
     initiate_oper(std::move(op));                                                           // Throws
 }
 
@@ -3086,7 +3085,7 @@ class Socket::ConnectOper : public ConnectOperBase {
 public:
     ConnectOper(std::size_t size, Socket& sock, H&& handler)
         : ConnectOperBase{size, sock}
-        , m_handler{std::move(handler)}
+        , m_handler{std::forward<H>(handler)}
     {
     }
     void recycle_and_execute() override final
@@ -3214,50 +3213,51 @@ inline std::size_t Socket::write_some(const char* data, std::size_t size, std::e
 template <class H>
 inline void Socket::async_connect(const Endpoint& ep, H&& handler)
 {
-    LendersConnectOperPtr op = Service::alloc<ConnectOper<H>>(m_write_oper, *this, std::move(handler)); // Throws
+    LendersConnectOperPtr op =
+        Service::alloc<ConnectOper<H>>(m_write_oper, *this, std::forward<H>(handler));                  // Throws
     m_desc.initiate_oper(std::move(op), ep);                                                            // Throws
 }
 
 template <class H>
 inline void Socket::async_read(char* buffer, std::size_t size, H&& handler)
 {
     bool is_read_some = false;
-    StreamOps::async_read(*this, buffer, size, is_read_some, std::move(handler)); // Throws
+    StreamOps::async_read(*this, buffer, size, is_read_some, std::forward<H>(handler)); // Throws
 }
 
 template <class H>
 inline void Socket::async_read(char* buffer, std::size_t size, ReadAheadBuffer& rab, H&& handler)
 {
     int delim = std::char_traits<char>::eof();
-    StreamOps::async_buffered_read(*this, buffer, size, delim, rab, std::move(handler)); // Throws
+    StreamOps::async_buffered_read(*this, buffer, size, delim, rab, std::forward<H>(handler)); // Throws
 }
 
 template <class H>
 inline void Socket::async_read_until(char* buffer, std::size_t size, char delim, ReadAheadBuffer& rab, H&& handler)
 {
     int delim_2 = std::char_traits<char>::to_int_type(delim);
-    StreamOps::async_buffered_read(*this, buffer, size, delim_2, rab, std::move(handler)); // Throws
+    StreamOps::async_buffered_read(*this, buffer, size, delim_2, rab, std::forward<H>(handler)); // Throws
 }
 
 template <class H>
 inline void Socket::async_write(const char* data, std::size_t size, H&& handler)
 {
     bool is_write_some = false;
-    StreamOps::async_write(*this, data, size, is_write_some, std::move(handler)); // Throws
+    StreamOps::async_write(*this, data, size, is_write_some, std::forward<H>(handler)); // Throws
 }
 
 template <class H>
 inline void Socket::async_read_some(char* buffer, std::size_t size, H&& handler)
 {
     bool is_read_some = true;
-    StreamOps::async_read(*this, buffer, size, is_read_some, std::move(handler)); // Throws
+    StreamOps::async_read(*this, buffer, size, is_read_some, std::forward<H>(handler)); // Throws
 }
 
 template <class H>
 inline void Socket::async_write_some(const char* data, std::size_t size, H&& handler)
 {
     bool is_write_some = true;
-    StreamOps::async_write(*this, data, size, is_write_some, std::move(handler)); // Throws
+    StreamOps::async_write(*this, data, size, is_write_some, std::forward<H>(handler)); // Throws
 }
 
 inline void Socket::shutdown(shutdown_type what)
@@ -3394,7 +3394,7 @@ class Acceptor::AcceptOper : public AcceptOperBase {
 public:
     AcceptOper(std::size_t size, Acceptor& a, Socket& s, Endpoint* e, H&& handler)
         : AcceptOperBase{size, a, s, e}
-        , m_handler{std::move(handler)}
+        , m_handler{std::forward<H>(handler)}
     {
     }
     void recycle_and_execute() override final
@@ -3456,13 +3456,13 @@ template <class H>
 inline void Acceptor::async_accept(Socket& sock, H&& handler)
 {
     Endpoint* ep = nullptr;
-    async_accept(sock, ep, std::move(handler)); // Throws
+    async_accept(sock, ep, std::forward<H>(handler)); // Throws
 }
 
 template <class H>
 inline void Acceptor::async_accept(Socket& sock, Endpoint& ep, H&& handler)
 {
-    async_accept(sock, &ep, std::move(handler)); // Throws
+    async_accept(sock, &ep, std::forward<H>(handler)); // Throws
 }
 
 inline std::error_code Acceptor::accept(Socket& socket, Endpoint* ep, std::error_code& ec)
@@ -3491,7 +3491,7 @@ inline void Acceptor::async_accept(Socket& sock, Endpoint* ep, H&& handler)
     if (REALM_UNLIKELY(sock.is_open()))
         throw util::runtime_error("Socket is already open");
     LendersAcceptOperPtr op = Service::alloc<AcceptOper<H>>(m_read_oper, *this, sock, ep,
-                                                            std::move(handler)); // Throws
+                                                            std::forward<H>(handler)); // Throws
     m_desc.initiate_oper(std::move(op));                                         // Throws
 }
 
@@ -3502,7 +3502,7 @@ class DeadlineTimer::WaitOper : public Service::WaitOperBase {
 public:
     WaitOper(std::size_t size, DeadlineTimer& timer, clock::time_point expiration_time, H&& handler)
         : Service::WaitOperBase{size, timer, expiration_time}
-        , m_handler{std::move(handler)}
+        , m_handler{std::forward<H>(handler)}
     {
     }
     void recycle_and_execute() override final
@@ -3542,7 +3542,7 @@ inline void DeadlineTimer::async_wait(std::chrono::duration<R, P> delay, H&& han
         throw util::overflow_error("Expiration time overflow");
     clock::time_point expiration_time = now + delay;
     initiate_oper(Service::alloc<WaitOper<H>>(m_wait_oper, *this, expiration_time,
-                                              std::move(handler))); // Throws
+                                              std::forward<H>(handler))); // Throws
 }
 
 // ---------------- ReadAheadBuffer ----------------
diff --git a/src/realm/table.cpp b/src/realm/table.cpp
@@ -560,6 +560,7 @@ void Table::remove_recursive(CascadeState& cascade_state)
     REALM_ASSERT(group);
     cascade_state.m_group = group;
 
+    std::vector<std::pair<TableKey, ObjKey>> to_delete;
     do {
         cascade_state.send_notifications();
 
@@ -572,14 +573,15 @@ void Table::remove_recursive(CascadeState& cascade_state)
         }
         cascade_state.m_to_be_nullified.clear();
 
-        auto to_delete = std::move(cascade_state.m_to_be_deleted);
-        for (auto obj : to_delete) {
-            auto table = group->get_table(obj.first);
+        to_delete.swap(cascade_state.m_to_be_deleted);
+        for (auto [table_key, obj_key] : to_delete) {
+            auto table = group->get_table(table_key);
             // This might add to the list of objects that should be deleted
-            REALM_ASSERT(!obj.second.is_unresolved());
-            table->m_clusters.erase(obj.second, cascade_state);
+            REALM_ASSERT(!obj_key.is_unresolved());
+            table->m_clusters.erase(obj_key, cascade_state);
         }
         nullify_links(cascade_state);
+        to_delete.clear();
     } while (!cascade_state.m_to_be_deleted.empty() || !cascade_state.m_to_be_nullified.empty());
 }
 
@@ -1679,7 +1681,7 @@ void copy_list<Timestamp>(ref_type sub_table_ref, Obj& obj, ColKey col, Allocato
 
 void Table::create_columns()
 {
-    size_t cnt;
+    size_t cnt = 0;
     auto get_column_cnt = [&cnt](const Cluster* cluster) {
         cnt = cluster->nb_columns();
         return IteratorControl::Stop;
diff --git a/src/realm/util/thread.hpp b/src/realm/util/thread.hpp
@@ -557,6 +557,7 @@ inline void Mutex::unlock() noexcept
 #else
     int r = pthread_mutex_unlock(&m_impl);
     REALM_ASSERT(r == 0);
+    static_cast<void>(r);
 #endif
 }
 
@@ -780,6 +781,7 @@ inline void CondVar::notify() noexcept
 #else
     int r = pthread_cond_signal(&m_impl);
     REALM_ASSERT(r == 0);
+    static_cast<void>(r);
 #endif
 }
 
@@ -790,6 +792,7 @@ inline void CondVar::notify_all() noexcept
 #else
     int r = pthread_cond_broadcast(&m_impl);
     REALM_ASSERT(r == 0);
+    static_cast<void>(r);
 #endif
 }
 
diff --git a/src/realm/uuid.cpp b/src/realm/uuid.cpp
diff --git a/test/object-store/util/test_utils.hpp b/test/object-store/util/test_utils.hpp
diff --git a/test/test_sync.cpp b/test/test_sync.cpp
diff --git a/test/test_util_network.cpp b/test/test_util_network.cpp

Original file line number	Diff line number	Diff line change
`@@ -742,9 +742,9 @@ void BPlusTreeBase::bptree_erase(size_t n, BPlusTreeNode::EraseFunc func)`
`742`	`742`	`ref_type new_root_ref = node->clear_first_bp_node_ref();`
`743`	`743`	`node->destroy_deep();`
`744`	`744`
`745`		`- auto new_root = create_root_from_ref(new_root_ref);`
`746`		`-`
`747`		`- replace_root(std::move(new_root));`
	`745`	`+ if (auto new_root = create_root_from_ref(new_root_ref)) {`
	`746`	`+ replace_root(std::move(new_root));`
	`747`	`+ }`
`748`	`748`	`root_size = m_root->get_node_size();`
`749`	`749`	`}`
`750`	`750`	`}`
`@@ -757,7 +757,7 @@ std::unique_ptr<BPlusTreeNode> BPlusTreeBase::create_root_from_ref(ref_type ref)`
`757`	`757`
`758`	`758`	`if (reuse_root) {`
`759`	`759`	`m_root->init_from_ref(ref);`
`760`		`- return std::move(m_root);`
	`760`	`+ return nullptr;`
`761`	`761`	`}`
`762`	`762`
`763`	`763`	`if (is_leaf) {`
Original file line number	Diff line number	Diff line change
`@@ -305,7 +305,8 @@ RLM_API bool realm_remove_table(realm_t* realm, const char* table_name, bool* ta`
`305`	`305`	`"Attempt to remove a table that is currently part of the schema");`
`306`	`306`	`}`
`307`	`307`	`(*realm)->read_group().remove_table(table->get_key());`
`308`		`- *table_deleted = true;`
	`308`	`+ if (table_deleted)`
	`309`	`+ *table_deleted = true;`
`309`	`310`	`}`
`310`	`311`	`return true;`
`311`	`312`	`});`
Original file line number	Diff line number	Diff line change
`@@ -1998,7 +1998,7 @@ class Service::PostOper : public PostOperBase {`
`1998`	`1998`	`public:`
`1999`	`1999`	`PostOper(std::size_t size, Impl& service, H&& handler)`
`2000`	`2000`	`: PostOperBase{size, service}`
`2001`		`- , m_handler{std::move(handler)}`
	`2001`	`+ , m_handler{std::forward<H>(handler)}`
`2002`	`2002`	`{`
`2003`	`2003`	`}`
`2004`	`2004`	`void recycle_and_execute() override final`
`@@ -2256,7 +2256,7 @@ class Service::BasicStreamOps {`
`2256`	`2256`	`char* begin = buffer;`
`2257`	`2257`	`char* end = buffer + size;`
`2258`	`2258`	`LendersReadOperPtr op = Service::alloc<ReadOper<H>>(stream.lowest_layer().m_read_oper, stream, is_read_some,`
`2259`		`- begin, end, std::move(handler)); // Throws`
	`2259`	`+ begin, end, std::forward<H>(handler)); // Throws`
`2260`	`2260`	`stream.lowest_layer().m_desc.initiate_oper(std::move(op)); // Throws`
`2261`	`2261`	`}`
`2262`	`2262`
`@@ -2265,8 +2265,9 @@ class Service::BasicStreamOps {`
`2265`	`2265`	`{`
`2266`	`2266`	`const char* begin = data;`
`2267`	`2267`	`const char* end = data + size;`
`2268`		`- LendersWriteOperPtr op = Service::alloc<WriteOper<H>>(`
`2269`		`- stream.lowest_layer().m_write_oper, stream, is_write_some, begin, end, std::move(handler)); // Throws`
	`2268`	`+ LendersWriteOperPtr op =`
	`2269`	`+ Service::alloc<WriteOper<H>>(stream.lowest_layer().m_write_oper, stream, is_write_some, begin, end,`
	`2270`	`+ std::forward<H>(handler)); // Throws`
`2270`	`2271`	`stream.lowest_layer().m_desc.initiate_oper(std::move(op)); // Throws`
`2271`	`2272`	`}`
`2272`	`2273`
`@@ -2278,7 +2279,7 @@ class Service::BasicStreamOps {`
`2278`	`2279`	`char* end = buffer + size;`
`2279`	`2280`	`LendersBufferedReadOperPtr op =`
`2280`	`2281`	`Service::alloc<BufferedReadOper<H>>(stream.lowest_layer().m_read_oper, stream, begin, end, delim, rab,`
`2281`		`- std::move(handler)); // Throws`
	`2282`	`+ std::forward<H>(handler)); // Throws`
`2282`	`2283`	`stream.lowest_layer().m_desc.initiate_oper(std::move(op)); // Throws`
`2283`	`2284`	`}`
`2284`	`2285`	`};`
`@@ -2554,7 +2555,7 @@ class Service::BasicStreamOps<S>::ReadOper : public ReadOperBase {`
`2554`	`2555`	`public:`
`2555`	`2556`	`ReadOper(std::size_t size, S& stream, bool is_read_some, char* begin, char* end, H&& handler)`
`2556`	`2557`	`: ReadOperBase{size, stream, is_read_some, begin, end}`
`2557`		`- , m_handler{std::move(handler)}`
	`2558`	`+ , m_handler{std::forward<H>(handler)}`
`2558`	`2559`	`{`
`2559`	`2560`	`}`
`2560`	`2561`	`void recycle_and_execute() override final`
`@@ -2584,7 +2585,7 @@ class Service::BasicStreamOps<S>::WriteOper : public WriteOperBase {`
`2584`	`2585`	`public:`
`2585`	`2586`	`WriteOper(std::size_t size, S& stream, bool is_write_some, const char* begin, const char* end, H&& handler)`
`2586`	`2587`	`: WriteOperBase{size, stream, is_write_some, begin, end}`
`2587`		`- , m_handler{std::move(handler)}`
	`2588`	`+ , m_handler{std::forward<H>(handler)}`
`2588`	`2589`	`{`
`2589`	`2590`	`}`
`2590`	`2591`	`void recycle_and_execute() override final`
`@@ -2615,7 +2616,7 @@ class Service::BasicStreamOps<S>::BufferedReadOper : public BufferedReadOperBase`
`2615`	`2616`	`BufferedReadOper(std::size_t size, S& stream, char* begin, char* end, int delim, ReadAheadBuffer& rab,`
`2616`	`2617`	`H&& handler)`
`2617`	`2618`	`: BufferedReadOperBase{size, stream, begin, end, delim, rab}`
`2618`		`- , m_handler{std::move(handler)}`
	`2619`	`+ , m_handler{std::forward<H>(handler)}`
`2619`	`2620`	`{`
`2620`	`2621`	`}`
`2621`	`2622`	`void recycle_and_execute() override final`
`@@ -2703,7 +2704,7 @@ template <class H>`
`2703`	`2704`	`inline Service::PostOperBase* Service::post_oper_constr(void* addr, std::size_t size, Impl& service, void* cookie)`
`2704`	`2705`	`{`
`2705`	`2706`	`H& handler = static_cast<H>(cookie);`
`2706`		`- return new (addr) PostOper<H>(size, service, std::move(handler)); // Throws`
	`2707`	`+ return new (addr) PostOper<H>(size, service, std::forward<H>(handler)); // Throws`
`2707`	`2708`	`}`
`2708`	`2709`
`2709`	`2710`	`inline bool Service::AsyncOper::in_use() const noexcept`
`@@ -2769,10 +2770,8 @@ inline void Service::AsyncOper::do_recycle_and_execute(bool orphaned, H& handler`
`2769`	`2770`	`// happens. For that reason, copying and moving of arguments must not`
`2770`	`2771`	`// happen until we are in a scope (this scope) that catches and deals`
`2771`	`2772`	`// correctly with such exceptions.`
`2772`		`- do_recycle_and_execute_helper(orphaned, was_recycled, std::move(handler),`
	`2773`	`+ do_recycle_and_execute_helper(orphaned, was_recycled, std::forward<H>(handler),`
`2773`	`2774`	`std::forward<Args>(args)...); // Throws`
`2774`		`-`
`2775`		`- // Removed catch to prevent truncating the stack trace on exception`
`2776`	`2775`	`}`
`2777`	`2776`
`2778`	`2777`	`template <class H, class... Args>`
`@@ -2805,7 +2804,7 @@ class Resolver::ResolveOper : public Service::ResolveOperBase {`
`2805`	`2804`	`public:`
`2806`	`2805`	`ResolveOper(std::size_t size, Resolver& r, Query q, H&& handler)`
`2807`	`2806`	`: ResolveOperBase{size, r, std::move(q)}`
`2808`		`- , m_handler{std::move(handler)}`
	`2807`	`+ , m_handler{std::forward<H>(handler)}`
`2809`	`2808`	`{`
`2810`	`2809`	`}`
`2811`	`2810`	`void recycle_and_execute() override final`
`@@ -2847,7 +2846,7 @@ template <class H>`
`2847`	`2846`	`void Resolver::async_resolve(Query query, H&& handler)`
`2848`	`2847`	`{`
`2849`	`2848`	`Service::LendersResolveOperPtr op = Service::alloc<ResolveOper<H>>(m_resolve_oper, *this, std::move(query),`
`2850`		`- std::move(handler)); // Throws`
	`2849`	`+ std::forward<H>(handler)); // Throws`
`2851`	`2850`	`initiate_oper(std::move(op)); // Throws`
`2852`	`2851`	`}`
`2853`	`2852`
`@@ -3086,7 +3085,7 @@ class Socket::ConnectOper : public ConnectOperBase {`
`3086`	`3085`	`public:`
`3087`	`3086`	`ConnectOper(std::size_t size, Socket& sock, H&& handler)`
`3088`	`3087`	`: ConnectOperBase{size, sock}`
`3089`		`- , m_handler{std::move(handler)}`
	`3088`	`+ , m_handler{std::forward<H>(handler)}`
`3090`	`3089`	`{`
`3091`	`3090`	`}`
`3092`	`3091`	`void recycle_and_execute() override final`
`@@ -3214,50 +3213,51 @@ inline std::size_t Socket::write_some(const char* data, std::size_t size, std::e`
`3214`	`3213`	`template <class H>`
`3215`	`3214`	`inline void Socket::async_connect(const Endpoint& ep, H&& handler)`
`3216`	`3215`	`{`
`3217`		`- LendersConnectOperPtr op = Service::alloc<ConnectOper<H>>(m_write_oper, *this, std::move(handler)); // Throws`
	`3216`	`+ LendersConnectOperPtr op =`
	`3217`	`+ Service::alloc<ConnectOper<H>>(m_write_oper, *this, std::forward<H>(handler)); // Throws`
`3218`	`3218`	`m_desc.initiate_oper(std::move(op), ep); // Throws`
`3219`	`3219`	`}`
`3220`	`3220`
`3221`	`3221`	`template <class H>`
`3222`	`3222`	`inline void Socket::async_read(char* buffer, std::size_t size, H&& handler)`
`3223`	`3223`	`{`
`3224`	`3224`	`bool is_read_some = false;`
`3225`		`- StreamOps::async_read(*this, buffer, size, is_read_some, std::move(handler)); // Throws`
	`3225`	`+ StreamOps::async_read(*this, buffer, size, is_read_some, std::forward<H>(handler)); // Throws`
`3226`	`3226`	`}`
`3227`	`3227`
`3228`	`3228`	`template <class H>`
`3229`	`3229`	`inline void Socket::async_read(char* buffer, std::size_t size, ReadAheadBuffer& rab, H&& handler)`
`3230`	`3230`	`{`
`3231`	`3231`	`int delim = std::char_traits<char>::eof();`
`3232`		`- StreamOps::async_buffered_read(*this, buffer, size, delim, rab, std::move(handler)); // Throws`
	`3232`	`+ StreamOps::async_buffered_read(*this, buffer, size, delim, rab, std::forward<H>(handler)); // Throws`
`3233`	`3233`	`}`
`3234`	`3234`
`3235`	`3235`	`template <class H>`
`3236`	`3236`	`inline void Socket::async_read_until(char* buffer, std::size_t size, char delim, ReadAheadBuffer& rab, H&& handler)`
`3237`	`3237`	`{`
`3238`	`3238`	`int delim_2 = std::char_traits<char>::to_int_type(delim);`
`3239`		`- StreamOps::async_buffered_read(*this, buffer, size, delim_2, rab, std::move(handler)); // Throws`
	`3239`	`+ StreamOps::async_buffered_read(*this, buffer, size, delim_2, rab, std::forward<H>(handler)); // Throws`
`3240`	`3240`	`}`
`3241`	`3241`
`3242`	`3242`	`template <class H>`
`3243`	`3243`	`inline void Socket::async_write(const char* data, std::size_t size, H&& handler)`
`3244`	`3244`	`{`
`3245`	`3245`	`bool is_write_some = false;`
`3246`		`- StreamOps::async_write(*this, data, size, is_write_some, std::move(handler)); // Throws`
	`3246`	`+ StreamOps::async_write(*this, data, size, is_write_some, std::forward<H>(handler)); // Throws`
`3247`	`3247`	`}`
`3248`	`3248`
`3249`	`3249`	`template <class H>`
`3250`	`3250`	`inline void Socket::async_read_some(char* buffer, std::size_t size, H&& handler)`
`3251`	`3251`	`{`
`3252`	`3252`	`bool is_read_some = true;`
`3253`		`- StreamOps::async_read(*this, buffer, size, is_read_some, std::move(handler)); // Throws`
	`3253`	`+ StreamOps::async_read(*this, buffer, size, is_read_some, std::forward<H>(handler)); // Throws`
`3254`	`3254`	`}`
`3255`	`3255`
`3256`	`3256`	`template <class H>`
`3257`	`3257`	`inline void Socket::async_write_some(const char* data, std::size_t size, H&& handler)`
`3258`	`3258`	`{`
`3259`	`3259`	`bool is_write_some = true;`
`3260`		`- StreamOps::async_write(*this, data, size, is_write_some, std::move(handler)); // Throws`
	`3260`	`+ StreamOps::async_write(*this, data, size, is_write_some, std::forward<H>(handler)); // Throws`
`3261`	`3261`	`}`
`3262`	`3262`
`3263`	`3263`	`inline void Socket::shutdown(shutdown_type what)`
`@@ -3394,7 +3394,7 @@ class Acceptor::AcceptOper : public AcceptOperBase {`
`3394`	`3394`	`public:`
`3395`	`3395`	`AcceptOper(std::size_t size, Acceptor& a, Socket& s, Endpoint* e, H&& handler)`
`3396`	`3396`	`: AcceptOperBase{size, a, s, e}`
`3397`		`- , m_handler{std::move(handler)}`
	`3397`	`+ , m_handler{std::forward<H>(handler)}`
`3398`	`3398`	`{`
`3399`	`3399`	`}`
`3400`	`3400`	`void recycle_and_execute() override final`
`@@ -3456,13 +3456,13 @@ template <class H>`
`3456`	`3456`	`inline void Acceptor::async_accept(Socket& sock, H&& handler)`
`3457`	`3457`	`{`
`3458`	`3458`	`Endpoint* ep = nullptr;`
`3459`		`- async_accept(sock, ep, std::move(handler)); // Throws`
	`3459`	`+ async_accept(sock, ep, std::forward<H>(handler)); // Throws`
`3460`	`3460`	`}`
`3461`	`3461`
`3462`	`3462`	`template <class H>`
`3463`	`3463`	`inline void Acceptor::async_accept(Socket& sock, Endpoint& ep, H&& handler)`
`3464`	`3464`	`{`
`3465`		`- async_accept(sock, &ep, std::move(handler)); // Throws`
	`3465`	`+ async_accept(sock, &ep, std::forward<H>(handler)); // Throws`
`3466`	`3466`	`}`
`3467`	`3467`
`3468`	`3468`	`inline std::error_code Acceptor::accept(Socket& socket, Endpoint* ep, std::error_code& ec)`
`@@ -3491,7 +3491,7 @@ inline void Acceptor::async_accept(Socket& sock, Endpoint* ep, H&& handler)`
`3491`	`3491`	`if (REALM_UNLIKELY(sock.is_open()))`
`3492`	`3492`	`throw util::runtime_error("Socket is already open");`
`3493`	`3493`	`LendersAcceptOperPtr op = Service::alloc<AcceptOper<H>>(m_read_oper, *this, sock, ep,`
`3494`		`- std::move(handler)); // Throws`
	`3494`	`+ std::forward<H>(handler)); // Throws`
`3495`	`3495`	`m_desc.initiate_oper(std::move(op)); // Throws`
`3496`	`3496`	`}`
`3497`	`3497`
`@@ -3502,7 +3502,7 @@ class DeadlineTimer::WaitOper : public Service::WaitOperBase {`
`3502`	`3502`	`public:`
`3503`	`3503`	`WaitOper(std::size_t size, DeadlineTimer& timer, clock::time_point expiration_time, H&& handler)`
`3504`	`3504`	`: Service::WaitOperBase{size, timer, expiration_time}`
`3505`		`- , m_handler{std::move(handler)}`
	`3505`	`+ , m_handler{std::forward<H>(handler)}`
`3506`	`3506`	`{`
`3507`	`3507`	`}`
`3508`	`3508`	`void recycle_and_execute() override final`
`@@ -3542,7 +3542,7 @@ inline void DeadlineTimer::async_wait(std::chrono::duration<R, P> delay, H&& han`
`3542`	`3542`	`throw util::overflow_error("Expiration time overflow");`
`3543`	`3543`	`clock::time_point expiration_time = now + delay;`
`3544`	`3544`	`initiate_oper(Service::alloc<WaitOper<H>>(m_wait_oper, *this, expiration_time,`
`3545`		`- std::move(handler))); // Throws`
	`3545`	`+ std::forward<H>(handler))); // Throws`
`3546`	`3546`	`}`
`3547`	`3547`
`3548`	`3548`	`// ---------------- ReadAheadBuffer ----------------`
Original file line number	Diff line number	Diff line change
`@@ -557,6 +557,7 @@ inline void Mutex::unlock() noexcept`
`557`	`557`	`#else`
`558`	`558`	`int r = pthread_mutex_unlock(&m_impl);`
`559`	`559`	`REALM_ASSERT(r == 0);`
	`560`	`+ static_cast<void>(r);`
`560`	`561`	`#endif`
`561`	`562`	`}`
`562`	`563`
`@@ -780,6 +781,7 @@ inline void CondVar::notify() noexcept`
`780`	`781`	`#else`
`781`	`782`	`int r = pthread_cond_signal(&m_impl);`
`782`	`783`	`REALM_ASSERT(r == 0);`
	`784`	`+ static_cast<void>(r);`
`783`	`785`	`#endif`
`784`	`786`	`}`
`785`	`787`
`@@ -790,6 +792,7 @@ inline void CondVar::notify_all() noexcept`
`790`	`792`	`#else`
`791`	`793`	`int r = pthread_cond_broadcast(&m_impl);`
`792`	`794`	`REALM_ASSERT(r == 0);`
	`795`	`+ static_cast<void>(r);`
`793`	`796`	`#endif`
`794`	`797`	`}`
`795`	`798`