QEvent: start to de-inline copy ctor and clone() of all subclasses

There's no advantage to them being inline: Absent de-virtualisation,
clone() is only supposed to be called through the vtable, and the copy
ctor is only supposed to be used in the implementation of clone().

And when the compiler de-virtualises, we don't want the code
duplication associated with inlining.

Enforce this by introducing new macros to hide the boilerplate.

This fixes missing out-of-line dtors in:
- QSinglePointEvent
- QApplicationStateChangeEvent
- QFutureCallOutEvent

Wrong covariant return in:
- QFutureCallOutEvent

And missing clone() reimplementations in:
- QCloseEvent
- QIconDragEvent
- QShowEvent
- QHideEvent
- QDragEnterEvent
- QDragLeaveEvent

While these don't carry extra data or members, a dynamic_cast of the
result of clone() as well as using the expected covariant return value
would fail:

   QShowEvent *e = ~~~;
   QShowEvent *e2 = e->clone(); // ERROR: converting QEvent* to QShowEvent*

Check that reimplementing clone() is binary compatible (covariant
returns may change the numerical pointer value returned, cf.
https://community.kde.org/Policies/Binary_Compatibility_Issues_With_C%2B%2B).

The copy-assignment operator stays inline for the time being, as the
goal is to = delete it in the future.

This patch covers, roughly, QtCore and QtGui.

[ChangeLog][QtGui][QEvent subclasses] Fixed missing clone()
reimplementations on QCloseEvent, QIconDragEvent, QShowEvent,
QHideEvent, QDragEnterEvent, and QDragLeaveEvent.

Task-number: QTBUG-45582
Task-number: QTBUG-97601
Change-Id: Ib8a0519dbe85a7a8da61050d48be338004dfa69a
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

1 files changed, 28 insertions, 16 deletions

diff --git a/src/corelib/kernel/qcoreevent.h b/src/corelib/kernel/qcoreevent.h
index 4a4910e893..f737a55514 100644
--- a/src/corelib/kernel/qcoreevent.h
+++ b/src/corelib/kernel/qcoreevent.h
@@ -53,6 +53,29 @@ protected: \
     Class &operator=(const Class &other) = default; \
     Class &operator=(Class &&) = delete
 
+#define Q_DECL_EVENT_COMMON(Class) \
+    protected: \
+        Class(const Class &); \
+        Class(Class &&) = delete; \
+        Class &operator=(const Class &other) = default; \
+        Class &operator=(Class &&) = delete; \
+    public: \
+        Class* clone() const override; \
+        ~Class() override; \
+    private:
+
+#define Q_IMPL_EVENT_COMMON(Class) \
+    Class::Class(const Class &) = default; \
+    Class::~Class() = default; \
+    Class* Class::clone() const \
+    { \
+        auto c = new Class(*this); \
+        QEvent *e = c; \
+        /* check that covariant return is safe to add */ \
+        Q_ASSERT(reinterpret_cast<quintptr>(c) == reinterpret_cast<quintptr>(e)); \
+        return c; \
+    }
+
 class QEventPrivate;
 class Q_CORE_EXPORT QEvent           // event base class
 {
@@ -367,14 +390,11 @@ private:
 
 class Q_CORE_EXPORT QTimerEvent : public QEvent
 {
-    Q_EVENT_DISABLE_COPY(QTimerEvent);
+    Q_DECL_EVENT_COMMON(QTimerEvent)
 public:
     explicit QTimerEvent(int timerId);
-    ~QTimerEvent();
     int timerId() const { return id; }
 
-    QTimerEvent *clone() const override { return new QTimerEvent(*this); }
-
 protected:
     int id;
 };
@@ -383,46 +403,38 @@ class QObject;
 
 class Q_CORE_EXPORT QChildEvent : public QEvent
 {
-    Q_EVENT_DISABLE_COPY(QChildEvent);
+    Q_DECL_EVENT_COMMON(QChildEvent)
 public:
     QChildEvent(Type type, QObject *child);
-    ~QChildEvent();
+
     QObject *child() const { return c; }
     bool added() const { return type() == ChildAdded; }
     bool polished() const { return type() == ChildPolished; }
     bool removed() const { return type() == ChildRemoved; }
 
-    QChildEvent *clone() const override { return new QChildEvent(*this); }
-
 protected:
     QObject *c;
 };
 
 class Q_CORE_EXPORT QDynamicPropertyChangeEvent : public QEvent
 {
-    Q_EVENT_DISABLE_COPY(QDynamicPropertyChangeEvent);
+    Q_DECL_EVENT_COMMON(QDynamicPropertyChangeEvent)
 public:
     explicit QDynamicPropertyChangeEvent(const QByteArray &name);
-    ~QDynamicPropertyChangeEvent();
 
     inline QByteArray propertyName() const { return n; }
 
-    QDynamicPropertyChangeEvent *clone() const override { return new QDynamicPropertyChangeEvent(*this); }
-
 private:
     QByteArray n;
 };
 
 class Q_CORE_EXPORT QDeferredDeleteEvent : public QEvent
 {
-    Q_EVENT_DISABLE_COPY(QDeferredDeleteEvent);
+    Q_DECL_EVENT_COMMON(QDeferredDeleteEvent)
 public:
     explicit QDeferredDeleteEvent();
-    ~QDeferredDeleteEvent();
     int loopLevel() const { return level; }
 
-    QDeferredDeleteEvent *clone() const override { return new QDeferredDeleteEvent(*this); }
-
 private:
     int level;
     friend class QCoreApplication;