2 files changed, 32 insertions, 21 deletions
diff --git a/src/corelib/itemmodels/qrangemodel_impl.h b/src/corelib/itemmodels/qrangemodel_impl.h
index 88bd6cf444e..55c7930cc36 100644
--- a/src/corelib/itemmodels/qrangemodel_impl.h
+++ b/src/corelib/itemmodels/qrangemodel_impl.h
@@ -109,14 +109,17 @@ namespace QRangeModelDetails
     using wrapped_t = std::remove_pointer_t<decltype(pointerTo(std::declval<T&>()))>;
 
     template <typename T>
-    using is_wrapped = std::negation<std::is_same<wrapped_t<T>, std::remove_reference_t<T>>>;
+    using is_wrapped = std::negation<std::is_same<
+            QRangeModelDetails::wrapped_t<T>, std::remove_reference_t<T>
+        >>;
 
     template <typename T, typename = void>
     struct tuple_like : std::false_type {};
     template <typename T, std::size_t N>
     struct tuple_like<std::array<T, N>> : std::false_type {};
     template <typename T>
-    struct tuple_like<T, std::void_t<std::tuple_element_t<0, wrapped_t<T>>>> : std::true_type {};
+    struct tuple_like<T, std::void_t<std::tuple_element_t<0, QRangeModelDetails::wrapped_t<T>>>>
+        : std::true_type {};
     template <typename T>
     [[maybe_unused]] static constexpr bool tuple_like_v = tuple_like<T>::value;
 
@@ -132,7 +135,7 @@ namespace QRangeModelDetails
     template <typename T, typename = void>
     struct has_metaobject : std::false_type {};
     template <typename T>
-    struct has_metaobject<T, std::void_t<decltype(wrapped_t<T>::staticMetaObject)>>
+    struct has_metaobject<T, std::void_t<decltype(QRangeModelDetails::wrapped_t<T>::staticMetaObject)>>
         : std::true_type {};
     template <typename T>
     [[maybe_unused]] static constexpr bool has_metaobject_v = has_metaobject<T>::value;
@@ -492,12 +495,12 @@ namespace QRangeModelDetails
 
     template <typename T>
     [[maybe_unused]] static constexpr int static_size_v =
-                            row_traits<std::remove_cv_t<wrapped_t<T>>>::static_size;
+            row_traits<std::remove_cv_t<QRangeModelDetails::wrapped_t<T>>>::static_size;
 
     template <typename Range>
     struct ListProtocol
     {
-        using row_type = typename range_traits<wrapped_t<Range>>::value_type;
+        using row_type = typename range_traits<QRangeModelDetails::wrapped_t<Range>>::value_type;
 
         template <typename R = row_type>
         auto newRow() -> decltype(R{}) { return R{}; }
@@ -506,16 +509,16 @@ namespace QRangeModelDetails
     template <typename Range>
     struct TableProtocol
     {
-        using row_type = typename range_traits<wrapped_t<Range>>::value_type;
+        using row_type = typename range_traits<QRangeModelDetails::wrapped_t<Range>>::value_type;
 
         template <typename R = row_type,
                   std::enable_if_t<std::conjunction_v<std::is_destructible<wrapped_t<R>>,
                                                       is_owning_or_raw_pointer<R>>, bool> = true>
-        auto newRow() -> decltype(R(new wrapped_t<R>)) {
+        auto newRow() -> decltype(R(new QRangeModelDetails::wrapped_t<R>)) {
             if constexpr (is_any_of<R, std::shared_ptr>())
-                return std::make_shared<wrapped_t<R>>();
+                return std::make_shared<QRangeModelDetails::wrapped_t<R>>();
             else
-                return R(new wrapped_t<R>);
+                return R(new QRangeModelDetails::wrapped_t<R>);
         }
 
         template <typename R = row_type,
@@ -527,7 +530,8 @@ namespace QRangeModelDetails
         auto deleteRow(R&& row) -> decltype(delete row) { delete row; }
     };
 
-    template <typename Range, typename R = typename range_traits<wrapped_t<Range>>::value_type>
+    template <typename Range,
+              typename R = typename range_traits<QRangeModelDetails::wrapped_t<Range>>::value_type>
     using table_protocol_t = std::conditional_t<static_size_v<R> == 0 && !has_metaobject_v<R>,
                                                 ListProtocol<Range>, TableProtocol<Range>>;
 
@@ -613,20 +617,23 @@ namespace QRangeModelDetails
             > : std::true_type {};
 
     template <typename Range>
-    using if_table_range = std::enable_if_t<std::conjunction_v<is_range<wrapped_t<Range>>,
-                                                    std::negation<is_tree_range<wrapped_t<Range>>>>,
-                                            bool>;
+    using if_table_range = std::enable_if_t<std::conjunction_v<
+            is_range<QRangeModelDetails::wrapped_t<Range>>,
+            std::negation<is_tree_range<QRangeModelDetails::wrapped_t<Range>>>
+        >, bool>;
 
     template <typename Range, typename Protocol = DefaultTreeProtocol<Range>>
-    using if_tree_range = std::enable_if_t<std::conjunction_v<is_range<wrapped_t<Range>>,
-                                              is_tree_range<wrapped_t<Range>, wrapped_t<Protocol>>>,
-                                           bool>;
+    using if_tree_range = std::enable_if_t<std::conjunction_v<
+            is_range<QRangeModelDetails::wrapped_t<Range>>,
+            is_tree_range<QRangeModelDetails::wrapped_t<Range>,
+                          QRangeModelDetails::wrapped_t<Protocol>>
+        >, bool>;
 
     template <typename Range, typename Protocol>
     struct protocol_traits
     {
-        using protocol = wrapped_t<Protocol>;
-        using row = typename range_traits<wrapped_t<Range>>::value_type;
+        using protocol = QRangeModelDetails::wrapped_t<Protocol>;
+        using row = typename range_traits<QRangeModelDetails::wrapped_t<Range>>::value_type;
         static constexpr bool is_tree = std::conjunction_v<protocol_parentRow<protocol, row>,
                                                            protocol_childRows<protocol, row>>;
         static constexpr bool is_list = static_size_v<row> == 0
@@ -713,7 +720,7 @@ namespace QRangeModelDetails
                        PropertyData<has_metaobject_v<ItemType>,
                                     std::is_base_of_v<QObject, std::remove_pointer_t<ItemType>>>
     {
-        using WrappedStorage = Storage<wrapped_t<ModelStorage>>;
+        using WrappedStorage = Storage<QRangeModelDetails::wrapped_t<ModelStorage>>;
         using iterator = typename WrappedStorage::iterator;
         using const_iterator = typename WrappedStorage::const_iterator;
 
@@ -985,8 +992,8 @@ protected:
             using std::distance;
 #endif
             using container_type = std::conditional_t<range_traits<C>::has_cbegin,
-                                                      const wrapped_t<C>,
-                                                      wrapped_t<C>>;
+                                                      const QRangeModelDetails::wrapped_t<C>,
+                                                      QRangeModelDetails::wrapped_t<C>>;
             container_type& container = const_cast<container_type &>(refTo(c));
             return int(distance(std::begin(container), std::end(container)));
         }
diff --git a/src/network/socket/qlocalsocket_unix.cpp b/src/network/socket/qlocalsocket_unix.cpp
index 76928bfb2c4..4e2a4e34e0e 100644
--- a/src/network/socket/qlocalsocket_unix.cpp
+++ b/src/network/socket/qlocalsocket_unix.cpp
@@ -68,7 +68,11 @@ void QLocalSocketPrivate::init()
     // QIODevice signals
     q->connect(&unixSocket, SIGNAL(bytesWritten(qint64)),
                q, SIGNAL(bytesWritten(qint64)));
+    q->connect(&unixSocket, SIGNAL(channelBytesWritten(int, qint64)),
+               q, SIGNAL(channelBytesWritten(int, qint64)));
     q->connect(&unixSocket, SIGNAL(readyRead()), q, SIGNAL(readyRead()));
+    q->connect(&unixSocket, SIGNAL(channelReadyRead(int)),
+               q, SIGNAL(channelReadyRead(int)));
     // QAbstractSocket signals
     q->connect(&unixSocket, SIGNAL(connected()), q, SIGNAL(connected()));
     q->connect(&unixSocket, SIGNAL(disconnected()), q, SIGNAL(disconnected()));