1 files changed, 49 insertions, 19 deletions

diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index ec1150120d..0958ab3ab5 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -14,23 +14,22 @@
 // We mean it.
 //
 
-#include "qv4global_p.h"
-#include "qv4context_p.h"
-#include "qv4stackframe_p.h"
 #include <private/qintrusivelist_p.h>
-#include "qv4enginebase_p.h"
-#include <private/qqmlrefcount_p.h>
 #include <private/qqmldelayedcallqueue_p.h>
-#include <QtCore/qelapsedtimer.h>
-#include <QtCore/qmutex.h>
-#include <QtCore/qset.h>
-#include <QtCore/qprocessordetection.h>
-
-#include "qv4function_p.h"
+#include <private/qqmlrefcount_p.h>
 #include <private/qv4compileddata_p.h>
+#include <private/qv4context_p.h>
+#include <private/qv4enginebase_p.h>
 #include <private/qv4executablecompilationunit_p.h>
+#include <private/qv4function_p.h>
+#include <private/qv4global_p.h>
 #include <private/qv4stacklimits_p.h>
 
+#include <QtCore/qelapsedtimer.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qprocessordetection.h>
+#include <QtCore/qset.h>
+
 namespace WTF {
 class BumpPointerAllocator;
 class PageAllocation;
@@ -76,7 +75,7 @@ namespace QV4 { struct QObjectMethod; }
 //     class MyClass : public QObject {
 //         Q_OBJECT
 //         ...
-//         Q_INVOKABLE void myMethod(QQmlV4Function*);
+//         Q_INVOKABLE void myMethod(QQmlV4FunctionPtr);
 //     };
 // The QQmlV8Function - and consequently the arguments and return value - only remains
 // valid during the call.  If the return value isn't set within myMethod(), the will return
@@ -110,6 +109,7 @@ class QQmlError;
 class QJSEngine;
 class QQmlEngine;
 class QQmlContextData;
+class QQmlTypeLoader;
 
 namespace QV4 {
 namespace Debugging {
@@ -174,6 +174,14 @@ public:
     QQmlEngine *qmlEngine() const { return m_qmlEngine; }
     QJSEngine *publicEngine;
 
+    template<typename TypeLoader = QQmlTypeLoader>
+    TypeLoader *typeLoader()
+    {
+        if (m_qmlEngine)
+            return TypeLoader::get(m_qmlEngine);
+        return nullptr;
+    }
+
     enum JSObjects {
         RootContext,
         ScriptContext,
@@ -209,6 +217,7 @@ public:
         MapProto,
         IntrinsicTypedArrayProto,
         ValueTypeProto,
+        TypeWrapperProto,
         SignalHandlerProto,
         IteratorProto,
         ForInIteratorProto,
@@ -334,6 +343,7 @@ public:
 
     Object *valueTypeWrapperPrototype() const { return reinterpret_cast<Object *>(jsObjects + ValueTypeProto); }
     Object *signalHandlerPrototype() const { return reinterpret_cast<Object *>(jsObjects + SignalHandlerProto); }
+    Object *typeWrapperPrototype() const { return reinterpret_cast<Object *>(jsObjects + TypeWrapperProto); }
     Object *iteratorPrototype() const { return reinterpret_cast<Object *>(jsObjects + IteratorProto); }
     Object *forInIteratorPrototype() const { return reinterpret_cast<Object *>(jsObjects + ForInIteratorProto); }
     Object *setIteratorPrototype() const { return reinterpret_cast<Object *>(jsObjects + SetIteratorProto); }
@@ -488,8 +498,6 @@ public:
     Symbol *symbol_unscopables() const { return reinterpret_cast<Symbol *>(jsSymbols + Symbol_unscopables); }
     Symbol *symbol_revokableProxy() const { return reinterpret_cast<Symbol *>(jsSymbols + Symbol_revokableProxy); }
 
-    QIntrusiveList<ExecutableCompilationUnit, &ExecutableCompilationUnit::nextCompilationUnit> compilationUnits;
-
     quint32 m_engineId;
 
     RegExpCache *regExpCache;
@@ -536,7 +544,14 @@ public:
     void setProfiler(Profiling::Profiler *profiler);
 #endif // QT_CONFIG(qml_debug)
 
-    ExecutionContext *currentContext() const { return currentStackFrame->context(); }
+    // We don't want to #include <private/qv4stackframe_p.h> here, but we still want
+    // currentContext() to be inline. Therefore we shift the requirement to provide the
+    // complete type of CppStackFrame to the caller by making this a template.
+    template<typename StackFrame = CppStackFrame>
+    ExecutionContext *currentContext() const
+    {
+        return static_cast<const StackFrame *>(currentStackFrame)->context();
+    }
 
     // ensure we always get odd prototype IDs. This helps make marking in QV4::Lookup fast
     quintptr newProtoId() { return (protoIdCount += 2); }
@@ -546,6 +561,7 @@ public:
     Heap::Object *newObject();
     Heap::Object *newObject(Heap::InternalClass *internalClass);
 
+    Heap::String *newString(char16_t c) { return newString(QChar(c)); }
     Heap::String *newString(const QString &s = QString());
     Heap::String *newIdentifier(const QString &text);
 
@@ -657,7 +673,8 @@ public:
 
     // variant conversions
     static QVariant toVariant(
-            const QV4::Value &value, QMetaType typeHint, bool createJSValueForObjects = true);
+        const QV4::Value &value, QMetaType typeHint, bool createJSValueForObjectsAndSymbols = true);
+    static QVariant toVariantLossy(const QV4::Value &value);
     QV4::ReturnedValue fromVariant(const QVariant &);
     QV4::ReturnedValue fromVariant(
             const QVariant &variant, Heap::Object *parent, int property, uint flags);
@@ -738,7 +755,21 @@ public:
     QQmlRefPointer<ExecutableCompilationUnit> compileModule(
             const QUrl &url, const QString &sourceCode, const QDateTime &sourceTimeStamp);
 
-    void injectCompiledModule(const QQmlRefPointer<ExecutableCompilationUnit> &moduleUnit);
+    QQmlRefPointer<ExecutableCompilationUnit> compilationUnitForUrl(const QUrl &url) const;
+
+    QQmlRefPointer<ExecutableCompilationUnit> executableCompilationUnit(
+            QQmlRefPointer<QV4::CompiledData::CompilationUnit> &&unit);
+
+    QQmlRefPointer<ExecutableCompilationUnit> insertCompilationUnit(
+            QQmlRefPointer<QV4::CompiledData::CompilationUnit> &&unit);
+
+    QMultiHash<QUrl, QQmlRefPointer<ExecutableCompilationUnit>> compilationUnits() const
+    {
+        return m_compilationUnits;
+    }
+    void clearCompilationUnits() { m_compilationUnits.clear(); }
+    void trimCompilationUnits();
+
     QV4::Value *registerNativeModule(const QUrl &url, const QV4::Value &module);
 
     struct Module {
@@ -854,8 +885,7 @@ private:
 
     QVector<Deletable *> m_extensionData;
 
-    mutable QMutex moduleMutex;
-    QHash<QUrl, QQmlRefPointer<ExecutableCompilationUnit>> modules;
+    QMultiHash<QUrl, QQmlRefPointer<ExecutableCompilationUnit>> m_compilationUnits;
 
     // QV4::PersistentValue would be preferred, but using QHash will create copies,
     // and QV4::PersistentValue doesn't like creating copies.