Merge remote-tracking branch 'origin/5.12' into 5.13

Change-Id: I2f0b4f8543a448c9acffe0932e0fd67c0b7412f4

4 files changed, 89 insertions, 44 deletions

diff --git a/src/qml/jsruntime/qv4internalclass.cpp b/src/qml/jsruntime/qv4internalclass.cpp
index 9906e2b1a0..8e2657f4a5 100644
--- a/src/qml/jsruntime/qv4internalclass.cpp
+++ b/src/qml/jsruntime/qv4internalclass.cpp
@@ -44,6 +44,7 @@
 #include "qv4object_p.h"
 #include "qv4identifiertable_p.h"
 #include "qv4value_p.h"
+#include "qv4mm_p.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -204,7 +205,62 @@ void SharedInternalClassDataPrivate<PropertyKey>::mark(MarkStack *s)
         data->mark(s);
 }
 
+SharedInternalClassDataPrivate<PropertyAttributes>::SharedInternalClassDataPrivate(
+        const SharedInternalClassDataPrivate<PropertyAttributes> &other, uint pos,
+        PropertyAttributes value)
+    : refcount(1),
+      m_alloc(pos + 8),
+      m_size(pos + 1),
+      m_engine(other.m_engine)
+{
+    m_engine->memoryManager->changeUnmanagedHeapSizeUsage(m_alloc * sizeof(PropertyAttributes));
+    data = new PropertyAttributes[m_alloc];
+    if (other.data)
+        memcpy(data, other.data, (m_size - 1) * sizeof(PropertyAttributes));
+    data[pos] = value;
+}
+
+SharedInternalClassDataPrivate<PropertyAttributes>::SharedInternalClassDataPrivate(
+        const SharedInternalClassDataPrivate<PropertyAttributes> &other)
+    : refcount(1),
+      m_alloc(other.m_alloc),
+      m_size(other.m_size),
+      m_engine(other.m_engine)
+{
+    if (m_alloc) {
+        m_engine->memoryManager->changeUnmanagedHeapSizeUsage(m_alloc * sizeof(PropertyAttributes));
+        data = new PropertyAttributes[m_alloc];
+        memcpy(data, other.data, m_size*sizeof(PropertyAttributes));
+    } else {
+        data = nullptr;
+    }
+}
 
+SharedInternalClassDataPrivate<PropertyAttributes>::~SharedInternalClassDataPrivate()
+{
+    m_engine->memoryManager->changeUnmanagedHeapSizeUsage(
+            -qptrdiff(m_alloc * sizeof(PropertyAttributes)));
+    delete [] data;
+}
+
+void SharedInternalClassDataPrivate<PropertyAttributes>::grow() {
+    if (!m_alloc) {
+        m_alloc = 4;
+        m_engine->memoryManager->changeUnmanagedHeapSizeUsage(
+                2 * m_alloc * sizeof(PropertyAttributes));
+    } else {
+        m_engine->memoryManager->changeUnmanagedHeapSizeUsage(
+                m_alloc * sizeof(PropertyAttributes));
+    }
+
+    auto *n = new PropertyAttributes[m_alloc * 2];
+    if (data) {
+        memcpy(n, data, m_alloc*sizeof(PropertyAttributes));
+        delete [] data;
+    }
+    data = n;
+    m_alloc *= 2;
+}
 
 namespace Heap {
 
diff --git a/src/qml/jsruntime/qv4internalclass_p.h b/src/qml/jsruntime/qv4internalclass_p.h
index 681cbda5f9..c689637721 100644
--- a/src/qml/jsruntime/qv4internalclass_p.h
+++ b/src/qml/jsruntime/qv4internalclass_p.h
@@ -149,55 +149,31 @@ inline PropertyHash::Entry *PropertyHash::lookup(PropertyKey identifier) const
     }
 }
 
-template<typename T>
-struct SharedInternalClassDataPrivate {
-    SharedInternalClassDataPrivate(ExecutionEngine *)
+template<class T>
+struct SharedInternalClassDataPrivate {};
+
+template<>
+struct SharedInternalClassDataPrivate<PropertyAttributes> {
+    SharedInternalClassDataPrivate(ExecutionEngine *engine)
         : refcount(1),
           m_alloc(0),
           m_size(0),
-          data(nullptr)
+          data(nullptr),
+          m_engine(engine)
     { }
-    SharedInternalClassDataPrivate(const SharedInternalClassDataPrivate &other)
-        : refcount(1),
-          m_alloc(other.m_alloc),
-          m_size(other.m_size)
-    {
-        if (m_alloc) {
-            data = new T[m_alloc];
-            memcpy(data, other.data, m_size*sizeof(T));
-        }
-    }
-    SharedInternalClassDataPrivate(const SharedInternalClassDataPrivate &other, uint pos, T value)
-        : refcount(1),
-          m_alloc(pos + 8),
-          m_size(pos + 1)
-    {
-        data = new T[m_alloc];
-        if (other.data)
-            memcpy(data, other.data, (m_size - 1)*sizeof(T));
-        data[pos] = value;
-    }
-    ~SharedInternalClassDataPrivate() { delete [] data; }
-
+    SharedInternalClassDataPrivate(const SharedInternalClassDataPrivate<PropertyAttributes> &other);
+    SharedInternalClassDataPrivate(const SharedInternalClassDataPrivate<PropertyAttributes> &other,
+                                   uint pos, PropertyAttributes value);
+    ~SharedInternalClassDataPrivate();
 
-    void grow() {
-        if (!m_alloc)
-            m_alloc = 4;
-        T *n = new T[m_alloc * 2];
-        if (data) {
-            memcpy(n, data, m_alloc*sizeof(T));
-            delete [] data;
-        }
-        data = n;
-        m_alloc *= 2;
-    }
+    void grow();
 
     uint alloc() const { return m_alloc; }
     uint size() const { return m_size; }
     void setSize(uint s) { m_size = s; }
 
-    T at(uint i) { Q_ASSERT(data && i < m_alloc); return data[i]; }
-    void set(uint i, T t) { Q_ASSERT(data && i < m_alloc); data[i] = t; }
+    PropertyAttributes at(uint i) { Q_ASSERT(data && i < m_alloc); return data[i]; }
+    void set(uint i, PropertyAttributes t) { Q_ASSERT(data && i < m_alloc); data[i] = t; }
 
     void mark(MarkStack *) {}
 
@@ -205,7 +181,8 @@ struct SharedInternalClassDataPrivate {
 private:
     uint m_alloc;
     uint m_size;
-    T *data;
+    PropertyAttributes *data;
+    ExecutionEngine *m_engine;
 };
 
 template<>
diff --git a/src/qml/jsruntime/qv4qmlcontext.cpp b/src/qml/jsruntime/qv4qmlcontext.cpp
index a2c8e3916f..12ada7ee70 100644
--- a/src/qml/jsruntime/qv4qmlcontext.cpp
+++ b/src/qml/jsruntime/qv4qmlcontext.cpp
@@ -465,10 +465,23 @@ ReturnedValue QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(Lookup *
             return static_cast<Heap::CallContext*>(ctx.d())->locals[index].asReturnedValue();
     }
 
-    Scoped<QQmlContextWrapper> qmlContext(scope, engine->qmlContext()->qml());
     bool hasProperty = false;
-    ScopedValue result(scope, QQmlContextWrapper::getPropertyAndBase(qmlContext, name, /*receiver*/nullptr,
-                                                                     &hasProperty, base, l));
+    ScopedValue result(scope);
+
+    Scoped<QmlContext> callingQmlContext(scope, engine->qmlContext());
+    if (callingQmlContext) {
+        Scoped<QQmlContextWrapper> qmlContextWrapper(scope, callingQmlContext->d()->qml());
+        result = QQmlContextWrapper::getPropertyAndBase(qmlContextWrapper, name, /*receiver*/nullptr, &hasProperty,
+                                                        base, l);
+    } else {
+        // Code path typical to worker scripts, compiled with lookups but no qml context.
+        result = l->resolveGlobalGetter(engine);
+        if (l->globalGetter != Lookup::globalGetterGeneric) {
+            hasProperty = true;
+            l->qmlContextGlobalLookup.getterTrampoline = l->globalGetter;
+            l->qmlContextPropertyGetter = QQmlContextWrapper::lookupInGlobalObject;
+        }
+    }
     if (!hasProperty)
         return engine->throwReferenceError(name.toQString());
     return result->asReturnedValue();
diff --git a/src/qml/jsruntime/qv4script.cpp b/src/qml/jsruntime/qv4script.cpp
index 7bbef3335e..6cb2e95cdc 100644
--- a/src/qml/jsruntime/qv4script.cpp
+++ b/src/qml/jsruntime/qv4script.cpp
@@ -201,7 +201,6 @@ QQmlRefPointer<QV4::CompiledData::CompilationUnit> Script::precompile(QV4::Compi
     }
 
     Codegen cg(unitGenerator, /*strict mode*/false);
-    cg.setUseFastLookups(false);
     cg.generateFromProgram(fileName, finalUrl, source, program, module, contextType);
     errors = cg.qmlErrors();
     if (!errors.isEmpty()) {