Implement dummy QML lookups for "global" variables

When resolving names in the context of QML bindings, we now direct
runtime access to QQmlContextWrapper::resolveQmlPropertyLookupGetter. At the
moment this does basically the same as Runtime::method_loadName, which
we called earlier. However this now provides the opportunity to optimize
lookups in the QML context in a central place.

When performing a call on a scope or context object property, we also
did not use a CallName() instruction - which would have gotten the
thisObject wrong - but instead we use a dedicated
CallScopeObjectProperty and CallContextObjectProperty instruction. These
rely on identifying these properties at compile time, which goes away
with lookups (and also doesn't work when using ahead-of-time
compilation). Therefore the qml context property lookup is using a
getPropertyAndBase style signature and
Runtime::method_callQmlContextPropertyLookup uses that.

For the tests to pass, some error expectations need adjusting. In
particular the compile-time detection of write attempts to id objects is
now delayed to the run-time.

The old code path is still there and will be removed separately in the
next commit (as it is massive).

Task-number: QTBUG-69898
Change-Id: Iad1ff93d3758c4db984a7c2d003beee21ed2275c
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>

1 files changed, 31 insertions, 18 deletions

diff --git a/src/qml/jsruntime/qv4runtime.cpp b/src/qml/jsruntime/qv4runtime.cpp
index 53dd3a66dd..7163a51af1 100644
--- a/src/qml/jsruntime/qv4runtime.cpp
+++ b/src/qml/jsruntime/qv4runtime.cpp
@@ -1301,18 +1301,42 @@ uint Runtime::method_compareIn(ExecutionEngine *engine, const Value &left, const
     return v->booleanValue();
 }
 
+static ReturnedValue throwPropertyIsNotAFunctionTypeError(ExecutionEngine *engine, Value *thisObject, const QString &propertyName)
+{
+    QString objectAsString = QStringLiteral("[null]");
+    if (!thisObject->isUndefined())
+        objectAsString = thisObject->toQStringNoThrow();
+    QString msg = QStringLiteral("Property '%1' of object %2 is not a function")
+                  .arg(propertyName, objectAsString);
+    return engine->throwTypeError(msg);
+}
 
 ReturnedValue Runtime::method_callGlobalLookup(ExecutionEngine *engine, uint index, Value *argv, int argc)
 {
+    Scope scope(engine);
     Lookup *l = engine->currentStackFrame->v4Function->compilationUnit->runtimeLookups + index;
     Value function = Value::fromReturnedValue(l->globalGetter(l, engine));
+    Value thisObject = Value::undefinedValue();
     if (!function.isFunctionObject())
-        return engine->throwTypeError();
+        return throwPropertyIsNotAFunctionTypeError(engine, &thisObject,
+                                                    engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[l->nameIndex]->toQString());
 
-    Value thisObject = Value::undefinedValue();
     return static_cast<FunctionObject &>(function).call(&thisObject, argv, argc);
 }
 
+ReturnedValue Runtime::method_callQmlContextPropertyLookup(ExecutionEngine *engine, uint index, Value *argv, int argc)
+{
+    Scope scope(engine);
+    ScopedValue thisObject(scope);
+    Lookup *l = engine->currentStackFrame->v4Function->compilationUnit->runtimeLookups + index;
+    Value function = Value::fromReturnedValue(l->qmlContextPropertyGetter(l, engine, thisObject));
+    if (!function.isFunctionObject())
+        return throwPropertyIsNotAFunctionTypeError(engine, thisObject,
+                                                    engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[l->nameIndex]->toQString());
+
+    return static_cast<FunctionObject &>(function).call(thisObject, argv, argc);
+}
+
 ReturnedValue Runtime::method_callPossiblyDirectEval(ExecutionEngine *engine, Value *argv, int argc)
 {
     Scope scope(engine);
@@ -1323,13 +1347,8 @@ ReturnedValue Runtime::method_callPossiblyDirectEval(ExecutionEngine *engine, Va
     if (engine->hasException)
         return Encode::undefined();
 
-    if (!function) {
-        QString objectAsString = QStringLiteral("[null]");
-        if (!thisObject->isUndefined())
-            objectAsString = thisObject->toQStringNoThrow();
-        QString msg = QStringLiteral("Property 'eval' of object %2 is not a function").arg(objectAsString);
-        return engine->throwTypeError(msg);
-    }
+    if (!function)
+        return throwPropertyIsNotAFunctionTypeError(engine, thisObject, QLatin1String("eval"));
 
     if (function->d() == engine->evalFunction()->d())
         return static_cast<EvalFunction *>(function.getPointer())->evalCall(thisObject, argv, argc, true);
@@ -1348,15 +1367,9 @@ ReturnedValue Runtime::method_callName(ExecutionEngine *engine, int nameIndex, V
     if (engine->hasException)
         return Encode::undefined();
 
-    if (!f) {
-        QString objectAsString = QStringLiteral("[null]");
-        if (!thisObject->isUndefined())
-            objectAsString = thisObject->toQStringNoThrow();
-        QString msg = QStringLiteral("Property '%1' of object %2 is not a function")
-                .arg(engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]->toQString(),
-                     objectAsString);
-        return engine->throwTypeError(msg);
-    }
+    if (!f)
+        return throwPropertyIsNotAFunctionTypeError(engine, thisObject,
+                                                    engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]->toQString());
 
     return f->call(thisObject, argv, argc);
 }