diff --git a/src/corelib/kernel/qobject.h b/src/corelib/kernel/qobject.h
index dbe5fc02a49..22572c072e2 100644
--- a/src/corelib/kernel/qobject.h
+++ b/src/corelib/kernel/qobject.h
@@ -212,7 +212,12 @@ public:
         reinterpret_cast<typename SignalType::Object *>(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast<typename SignalType::Object *>(0));
 
         //compilation error if the arguments does not match.
-        typedef typename QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::IncompatibleSignalSlotArguments EnsureCompatibleArguments;
+        Q_STATIC_ASSERT_X(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount),
+                          "The slot requires more arguments than the signal provides.");
+        Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value),
+                          "Signal and slot arguments are not compatible.");
+        Q_STATIC_ASSERT_X((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value),
+                          "Return type of the slot is not compatible with the return type of the signal.");
 
         const int *types = 0;
         if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
@@ -234,8 +239,12 @@ public:
         typedef QtPrivate::FunctionPointer<Func2> SlotType;
 
         //compilation error if the arguments does not match.
-        typedef typename QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::IncompatibleSignalSlotArguments EnsureCompatibleArguments;
-        typedef typename QtPrivate::QEnableIf<(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount))>::Type EnsureArgumentsCount;
+        Q_STATIC_ASSERT_X(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount),
+                          "The slot requires more arguments than the signal provides.");
+        Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value),
+                          "Signal and slot arguments are not compatible.");
+        Q_STATIC_ASSERT_X((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value),
+                          "Return type of the slot is not compatible with the return type of the signal.");
 
         return connectImpl(sender, reinterpret_cast<void **>(&signal), sender, 0,
                            new QStaticSlotObject<Func2,
@@ -276,7 +285,9 @@ public:
         reinterpret_cast<typename SignalType::Object *>(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast<typename SignalType::Object *>(0));
 
         //compilation error if the arguments does not match.
-        typedef typename QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::IncompatibleSignalSlotArguments EnsureCompatibleArguments;
+        Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value),
+                          "Signal and slot arguments are not compatible.");
+
         return disconnectImpl(sender, reinterpret_cast<void **>(&signal), receiver, reinterpret_cast<void **>(&slot),
                               &SignalType::Object::staticMetaObject);
     }
diff --git a/src/corelib/kernel/qobject_impl.h b/src/corelib/kernel/qobject_impl.h
index 660294b9564..1ddc95fc44a 100644
--- a/src/corelib/kernel/qobject_impl.h
+++ b/src/corelib/kernel/qobject_impl.h
@@ -441,36 +441,40 @@ namespace QtPrivate {
     /*
        Logic that check if the arguments of the slot matches the argument of the signal.
        To be used like this:
-       CheckCompatibleArguments<FunctionPointer<Signal>::Arguments, FunctionPointer<Slot>::Arguments>::IncompatibleSignalSlotArguments
-       The IncompatibleSignalSlotArguments type do not exist if the argument are incompatible and can
-       then produce error message.
+       Q_STATIC_ASSERT(CheckCompatibleArguments<FunctionPointer<Signal>::Arguments, FunctionPointer<Slot>::Arguments>::value)
     */
-    template<typename T, bool B> struct CheckCompatibleArgumentsHelper {};
-    template<typename T> struct CheckCompatibleArgumentsHelper<T, true> : T {};
     template<typename A1, typename A2> struct AreArgumentsCompatible {
         static int test(A2);
         static char test(...);
-        static A2 dummy();
+        static A1 dummy();
         enum { value = sizeof(test(dummy())) == sizeof(int) };
     };
     template<typename A1, typename A2> struct AreArgumentsCompatible<A1, A2&> { enum { value = false }; };
     template<typename A> struct AreArgumentsCompatible<A&, A&> { enum { value = true }; };
+    // void as a return value
+    template<typename A> struct AreArgumentsCompatible<void, A> { enum { value = true }; };
+    template<typename A> struct AreArgumentsCompatible<A, void> { enum { value = true }; };
+    template<> struct AreArgumentsCompatible<void, void> { enum { value = true }; };
 
 #ifndef Q_COMPILER_VARIADIC_TEMPLATES
-    template <typename List1, typename List2> struct CheckCompatibleArguments{};
-    template <> struct CheckCompatibleArguments<void, void> { typedef bool IncompatibleSignalSlotArguments; };
-    template <typename List1> struct CheckCompatibleArguments<List1, void> { typedef bool IncompatibleSignalSlotArguments; };
+    template <typename List1, typename List2> struct CheckCompatibleArguments { enum { value = false }; };
+    template <> struct CheckCompatibleArguments<void, void> { enum { value = true }; };
+    template <typename List1> struct CheckCompatibleArguments<List1, void> { enum { value = true }; };
     template <typename Arg1, typename Arg2, typename Tail1, typename Tail2> struct CheckCompatibleArguments<List<Arg1, Tail1>, List<Arg2, Tail2> >
-        : CheckCompatibleArgumentsHelper<CheckCompatibleArguments<Tail1, Tail2>, AreArgumentsCompatible<
-            typename RemoveConstRef<Arg1>::Type, typename RemoveConstRef<Arg2>::Type>::value > {};
+    {
+        enum { value = AreArgumentsCompatible<typename RemoveConstRef<Arg1>::Type, typename RemoveConstRef<Arg2>::Type>::value
+                    && CheckCompatibleArguments<Tail1, Tail2>::value };
+    };
 #else
-    template <typename List1, typename List2> struct CheckCompatibleArguments{};
-    template <> struct CheckCompatibleArguments<List<>, List<>> { typedef bool IncompatibleSignalSlotArguments; };
-    template <typename List1> struct CheckCompatibleArguments<List1, List<>> { typedef bool IncompatibleSignalSlotArguments; };
+    template <typename List1, typename List2> struct CheckCompatibleArguments { enum { value = false }; };
+    template <> struct CheckCompatibleArguments<List<>, List<>> { enum { value = true }; };
+    template <typename List1> struct CheckCompatibleArguments<List1, List<>> { enum { value = true }; };
     template <typename Arg1, typename Arg2, typename... Tail1, typename... Tail2>
     struct CheckCompatibleArguments<List<Arg1, Tail1...>, List<Arg2, Tail2...>>
-        : CheckCompatibleArgumentsHelper<CheckCompatibleArguments<List<Tail1...>, List<Tail2...>>, AreArgumentsCompatible<
-            typename RemoveConstRef<Arg1>::Type, typename RemoveConstRef<Arg2>::Type>::value > {};
+    {
+        enum { value = AreArgumentsCompatible<typename RemoveConstRef<Arg1>::Type, typename RemoveConstRef<Arg2>::Type>::value
+                    && CheckCompatibleArguments<List<Tail1...>, List<Tail2...>>::value };
+    };
 
 #endif