Fix void * usage in our internal APIs

Task-number: QTBUG-61536
Change-Id: Ia2b5cfeab093d8be91728032528788dd238c2872
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

7 files changed, 60 insertions, 63 deletions

diff --git a/src/qml/compiler/qqmlirbuilder.cpp b/src/qml/compiler/qqmlirbuilder.cpp
index 5bbf067320..8db054c91f 100644
--- a/src/qml/compiler/qqmlirbuilder.cpp
+++ b/src/qml/compiler/qqmlirbuilder.cpp
@@ -1749,7 +1749,7 @@ static void initQmlTypeResolver(QV4::IR::MemberExpressionResolver *resolver, con
 
     resolver->resolveMember = &resolveQmlType;
     resolver->qmlType = qmlType;
-    resolver->extraData = 0;
+    resolver->typenameCache = 0;
     resolver->flags = 0;
 }
 
@@ -1758,8 +1758,8 @@ static QV4::IR::DiscoveredType resolveImportNamespace(
         QV4::IR::Member *member)
 {
     QV4::IR::Type result = QV4::IR::VarType;
-    QQmlTypeNameCache *typeNamespace = static_cast<QQmlTypeNameCache*>(resolver->extraData);
-    void *importNamespace = resolver->data;
+    QQmlTypeNameCache *typeNamespace = resolver->typenameCache;
+    const QQmlImportRef *importNamespace = resolver->import;
 
     QQmlTypeNameCache::Result r = typeNamespace->query(*member->name, importNamespace);
     if (r.isValid()) {
@@ -1786,11 +1786,11 @@ static QV4::IR::DiscoveredType resolveImportNamespace(
 }
 
 static void initImportNamespaceResolver(QV4::IR::MemberExpressionResolver *resolver,
-                                        QQmlTypeNameCache *imports, const void *importNamespace)
+                                        QQmlTypeNameCache *imports, const QQmlImportRef *importNamespace)
 {
     resolver->resolveMember = &resolveImportNamespace;
-    resolver->data = const_cast<void*>(importNamespace);
-    resolver->extraData = imports;
+    resolver->import = importNamespace;
+    resolver->typenameCache = imports;
     resolver->flags = 0;
 }
 
@@ -1799,7 +1799,7 @@ static QV4::IR::DiscoveredType resolveMetaObjectProperty(
         QV4::IR::Member *member)
 {
     QV4::IR::Type result = QV4::IR::VarType;
-    QQmlPropertyCache *metaObject = static_cast<QQmlPropertyCache*>(resolver->data);
+    QQmlPropertyCache *metaObject = resolver->propertyCache;
 
     if (member->name->constData()->isUpper() && (resolver->flags & LookupsIncludeEnums)) {
         const QMetaObject *mo = metaObject->createMetaObject();
@@ -1881,7 +1881,7 @@ static void initMetaObjectResolver(QV4::IR::MemberExpressionResolver *resolver,
     Q_ASSERT(resolver);
 
     resolver->resolveMember = &resolveMetaObjectProperty;
-    resolver->data = metaObject;
+    resolver->propertyCache = metaObject;
     resolver->flags = 0;
 }
 
diff --git a/src/qml/compiler/qv4jsir_p.h b/src/qml/compiler/qv4jsir_p.h
index e9344a31fb..5c8e79f404 100644
--- a/src/qml/compiler/qv4jsir_p.h
+++ b/src/qml/compiler/qv4jsir_p.h
@@ -80,6 +80,8 @@ class QQmlType;
 class QQmlPropertyData;
 class QQmlPropertyCache;
 class QQmlEnginePrivate;
+struct QQmlImportRef;
+class QQmlTypeNameCache;
 
 namespace QV4 {
 
@@ -251,7 +253,7 @@ struct MemberExpressionResolver
                                               Member *member);
 
     MemberExpressionResolver()
-        : resolveMember(0), data(0), extraData(0), owner(nullptr), flags(0) {}
+        : resolveMember(0), import(nullptr), propertyCache(nullptr), typenameCache(nullptr), owner(nullptr), flags(0) {}
 
     bool isValid() const { return !!resolveMember; }
     void clear() { *this = MemberExpressionResolver(); }
@@ -260,8 +262,9 @@ struct MemberExpressionResolver
 #ifndef V4_BOOTSTRAP
     QQmlType qmlType;
 #endif
-    void *data; // Could be pointer to meta object or importNameSpace
-    void *extraData; // Could be QQmlTypeNameCache
+    const QQmlImportRef *import;
+    QQmlPropertyCache *propertyCache;
+    QQmlTypeNameCache *typenameCache;
     Function *owner;
     unsigned int flags;
 };
diff --git a/src/qml/qml/qqmlimport.cpp b/src/qml/qml/qqmlimport.cpp
index e197efe72b..0bd7317470 100644
--- a/src/qml/qml/qqmlimport.cpp
+++ b/src/qml/qml/qqmlimport.cpp
@@ -420,13 +420,14 @@ void QQmlImports::populateCache(QQmlTypeNameCache *cache) const
         const QQmlImportNamespace &set = *ns;
 
         // positioning is important; we must create the namespace even if there is no module.
-        QQmlTypeNameCache::Import &typeimport = cache->m_namedImports[set.prefix];
+        QQmlImportRef &typeimport = cache->m_namedImports[set.prefix];
         typeimport.m_qualifier = set.prefix;
 
         for (int ii = set.imports.count() - 1; ii >= 0; --ii) {
             const QQmlImportInstance *import = set.imports.at(ii);
             QQmlTypeModule *module = QQmlMetaType::typeModule(import->uri, import->majversion);
             if (module) {
+                QQmlImportRef &typeimport = cache->m_namedImports[set.prefix];
                 typeimport.modules.append(QQmlTypeModuleVersion(module, import->minversion));
             }
         }
diff --git a/src/qml/qml/qqmltypenamecache.cpp b/src/qml/qml/qqmltypenamecache.cpp
index a8f55d2e48..72307c2800 100644
--- a/src/qml/qml/qqmltypenamecache.cpp
+++ b/src/qml/qml/qqmltypenamecache.cpp
@@ -55,7 +55,7 @@ QQmlTypeNameCache::~QQmlTypeNameCache()
 void QQmlTypeNameCache::add(const QHashedString &name, const QUrl &url, const QHashedString &nameSpace)
 {
     if (nameSpace.length() != 0) {
-        Import *i = m_namedImports.value(nameSpace);
+        QQmlImportRef *i = m_namedImports.value(nameSpace);
         Q_ASSERT(i != 0);
         i->compositeSingletons.insert(name, url);
         return;
@@ -69,12 +69,12 @@ void QQmlTypeNameCache::add(const QHashedString &name, const QUrl &url, const QH
 
 void QQmlTypeNameCache::add(const QHashedString &name, int importedScriptIndex, const QHashedString &nameSpace)
 {
-    Import import;
+    QQmlImportRef import;
     import.scriptIndex = importedScriptIndex;
     import.m_qualifier = name;
 
     if (nameSpace.length() != 0) {
-        Import *i = m_namedImports.value(nameSpace);
+        QQmlImportRef *i = m_namedImports.value(nameSpace);
         Q_ASSERT(i != 0);
         m_namespacedImports[i].insert(name, import);
         return;
@@ -112,22 +112,20 @@ QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QHashedStringRef &name)
 }
 
 QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QHashedStringRef &name,
-                                                   const void *importNamespace) const
+                                                   const QQmlImportRef *importNamespace) const
 {
-    Q_ASSERT(importNamespace);
-    const Import *i = static_cast<const Import *>(importNamespace);
-    Q_ASSERT(i->scriptIndex == -1);
+    Q_ASSERT(importNamespace && importNamespace->scriptIndex == -1);
 
-    Result result = typeSearch(i->modules, name);
+    Result result = typeSearch(importNamespace->modules, name);
 
     if (!result.isValid())
-        result = query(i->compositeSingletons, name);
+        result = query(importNamespace->compositeSingletons, name);
 
     if (!result.isValid()) {
         // Look up types from the imports of this document
         // ### it would be nice if QQmlImports allowed us to resolve a namespace
         // first, and then types on it.
-        QString qualifiedTypeName = i->m_qualifier + QLatin1Char('.') + name.toString();
+        QString qualifiedTypeName = importNamespace->m_qualifier + QLatin1Char('.') + name.toString();
         QQmlImportNamespace *typeNamespace = 0;
         QList<QQmlError> errors;
         QQmlType t;
@@ -166,29 +164,27 @@ QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QV4::String *name) cons
     return result;
 }
 
-QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QV4::String *name, const void *importNamespace) const
+QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QV4::String *name, const QQmlImportRef *importNamespace) const
 {
-    Q_ASSERT(importNamespace);
-    const Import *i = static_cast<const Import *>(importNamespace);
-    Q_ASSERT(i->scriptIndex == -1);
+    Q_ASSERT(importNamespace && importNamespace->scriptIndex == -1);
 
-    QMap<const Import *, QStringHash<Import> >::const_iterator it = m_namespacedImports.constFind(i);
+    QMap<const QQmlImportRef *, QStringHash<QQmlImportRef> >::const_iterator it = m_namespacedImports.constFind(importNamespace);
     if (it != m_namespacedImports.constEnd()) {
         Result r = query(*it, name);
         if (r.isValid())
             return r;
     }
 
-    Result r = typeSearch(i->modules, name);
+    Result r = typeSearch(importNamespace->modules, name);
 
     if (!r.isValid())
-        r = query(i->compositeSingletons, name);
+        r = query(importNamespace->compositeSingletons, name);
 
     if (!r.isValid()) {
         // Look up types from the imports of this document
         // ### it would be nice if QQmlImports allowed us to resolve a namespace
         // first, and then types on it.
-        QString qualifiedTypeName = i->m_qualifier + QLatin1Char('.') + name->toQStringNoThrow();
+        QString qualifiedTypeName = importNamespace->m_qualifier + QLatin1Char('.') + name->toQStringNoThrow();
         QQmlImportNamespace *typeNamespace = 0;
         QList<QQmlError> errors;
         QQmlType t;
diff --git a/src/qml/qml/qqmltypenamecache_p.h b/src/qml/qml/qqmltypenamecache_p.h
index 0705166ec2..7e2cbec4b5 100644
--- a/src/qml/qml/qqmltypenamecache_p.h
+++ b/src/qml/qml/qqmltypenamecache_p.h
@@ -62,6 +62,23 @@
 
 QT_BEGIN_NAMESPACE
 
+struct QQmlImportRef {
+    inline QQmlImportRef()
+        : scriptIndex(-1)
+    {}
+    // Imported module
+    QVector<QQmlTypeModuleVersion> modules;
+
+    // Or, imported script
+    int scriptIndex;
+
+    // Or, imported compositeSingletons
+    QStringHash<QUrl> compositeSingletons;
+
+    // The qualifier of this import
+    QString m_qualifier;
+};
+
 class QQmlType;
 class QQmlEngine;
 class QQmlTypeNameCache : public QQmlRefCount
@@ -77,7 +94,7 @@ public:
 
     struct Result {
         inline Result();
-        inline Result(const void *importNamespace);
+        inline Result(const QQmlImportRef *importNamespace);
         inline Result(const QQmlType &type);
         inline Result(int scriptIndex);
         inline Result(const Result &);
@@ -85,42 +102,27 @@ public:
         inline bool isValid() const;
 
         QQmlType type;
-        const void *importNamespace;
+        const QQmlImportRef *importNamespace;
         int scriptIndex;
     };
     Result query(const QHashedStringRef &) const;
-    Result query(const QHashedStringRef &, const void *importNamespace) const;
+    Result query(const QHashedStringRef &, const QQmlImportRef *importNamespace) const;
     Result query(const QV4::String *) const;
-    Result query(const QV4::String *, const void *importNamespace) const;
+    Result query(const QV4::String *, const QQmlImportRef *importNamespace) const;
 
 private:
     friend class QQmlImports;
 
-    struct Import {
-        inline Import();
-        // Imported module
-        QVector<QQmlTypeModuleVersion> modules;
-
-        // Or, imported script
-        int scriptIndex;
-
-        // Or, imported compositeSingletons
-        QStringHash<QUrl> compositeSingletons;
-
-        // The qualifier of this import
-        QString m_qualifier;
-    };
-
     template<typename Key>
-    Result query(const QStringHash<Import> &imports, Key key) const
+    Result query(const QStringHash<QQmlImportRef> &imports, Key key) const
     {
-        Import *i = imports.value(key);
+        QQmlImportRef *i = imports.value(key);
         if (i) {
             Q_ASSERT(!i->m_qualifier.isEmpty());
             if (i->scriptIndex != -1) {
                 return Result(i->scriptIndex);
             } else {
-                return Result(static_cast<const void *>(i));
+                return Result(i);
             }
         }
 
@@ -152,8 +154,8 @@ private:
         return Result();
     }
 
-    QStringHash<Import> m_namedImports;
-    QMap<const Import *, QStringHash<Import> > m_namespacedImports;
+    QStringHash<QQmlImportRef> m_namedImports;
+    QMap<const QQmlImportRef *, QStringHash<QQmlImportRef> > m_namespacedImports;
     QVector<QQmlTypeModuleVersion> m_anonymousImports;
     QStringHash<QUrl> m_anonymousCompositeSingletons;
     QQmlImports m_imports;
@@ -164,7 +166,7 @@ QQmlTypeNameCache::Result::Result()
 {
 }
 
-QQmlTypeNameCache::Result::Result(const void *importNamespace)
+QQmlTypeNameCache::Result::Result(const QQmlImportRef *importNamespace)
 : importNamespace(importNamespace), scriptIndex(-1)
 {
 }
@@ -189,11 +191,6 @@ bool QQmlTypeNameCache::Result::isValid() const
     return type.isValid() || importNamespace || scriptIndex != -1;
 }
 
-QQmlTypeNameCache::Import::Import()
-: scriptIndex(-1)
-{
-}
-
 bool QQmlTypeNameCache::isEmpty() const
 {
     return m_namedImports.isEmpty() && m_anonymousImports.isEmpty()
diff --git a/src/qml/qml/qqmltypewrapper.cpp b/src/qml/qml/qqmltypewrapper.cpp
index ba07b77c72..d4e1910a72 100644
--- a/src/qml/qml/qqmltypewrapper.cpp
+++ b/src/qml/qml/qqmltypewrapper.cpp
@@ -119,7 +119,7 @@ ReturnedValue QmlTypeWrapper::create(QV4::ExecutionEngine *engine, QObject *o, c
 
 // Returns a type wrapper for importNamespace (of t) on o.  This allows nested resolution of a type in a
 // namespace.
-ReturnedValue QmlTypeWrapper::create(QV4::ExecutionEngine *engine, QObject *o, QQmlTypeNameCache *t, const void *importNamespace,
+ReturnedValue QmlTypeWrapper::create(QV4::ExecutionEngine *engine, QObject *o, QQmlTypeNameCache *t, const QQmlImportRef *importNamespace,
                                      Heap::QmlTypeWrapper::TypeNameMode mode)
 {
     Q_ASSERT(t);
diff --git a/src/qml/qml/qqmltypewrapper_p.h b/src/qml/qml/qqmltypewrapper_p.h
index c21a66424b..c06c485fb8 100644
--- a/src/qml/qml/qqmltypewrapper_p.h
+++ b/src/qml/qml/qqmltypewrapper_p.h
@@ -80,7 +80,7 @@ struct QmlTypeWrapper : Object {
 
     QQmlTypePrivate *typePrivate;
     QQmlTypeNameCache *typeNamespace;
-    const void *importNamespace;
+    const QQmlImportRef *importNamespace;
 };
 
 }
@@ -97,7 +97,7 @@ struct Q_QML_EXPORT QmlTypeWrapper : Object
 
     static ReturnedValue create(ExecutionEngine *, QObject *, const QQmlType &,
                                 Heap::QmlTypeWrapper::TypeNameMode = Heap::QmlTypeWrapper::IncludeEnums);
-    static ReturnedValue create(ExecutionEngine *, QObject *, QQmlTypeNameCache *, const void *,
+    static ReturnedValue create(ExecutionEngine *, QObject *, QQmlTypeNameCache *, const QQmlImportRef *,
                                 Heap::QmlTypeWrapper::TypeNameMode = Heap::QmlTypeWrapper::IncludeEnums);