diff options
Diffstat (limited to 'src/qml')
80 files changed, 1058 insertions, 621 deletions
diff --git a/src/qml/CMakeLists.txt b/src/qml/CMakeLists.txt index fa672d3d6c..cbcdc2f8f9 100644 --- a/src/qml/CMakeLists.txt +++ b/src/qml/CMakeLists.txt @@ -255,6 +255,7 @@ qt_internal_add_qml_module(Qml jsruntime/qv4property_p.h jsruntime/qv4propertykey.cpp jsruntime/qv4propertykey_p.h jsruntime/qv4proxy.cpp jsruntime/qv4proxy_p.h + jsruntime/qv4qmetaobjectwrapper.cpp jsruntime/qv4qmetaobjectwrapper_p.h jsruntime/qv4qmlcontext.cpp jsruntime/qv4qmlcontext_p.h jsruntime/qv4qobjectwrapper.cpp jsruntime/qv4qobjectwrapper_p.h jsruntime/qv4reflect.cpp jsruntime/qv4reflect_p.h diff --git a/src/qml/Qt6QmlBuildInternals.cmake b/src/qml/Qt6QmlBuildInternals.cmake index 418b552692..7b181fabde 100644 --- a/src/qml/Qt6QmlBuildInternals.cmake +++ b/src/qml/Qt6QmlBuildInternals.cmake @@ -94,7 +94,6 @@ function(qt_internal_add_qml_module target) ) # TODO: Remove these once all repos have been updated to not use them set(ignore_option_args - SKIP_TYPE_REGISTRATION # Now always done PLUGIN_OPTIONAL # Now the default GENERATE_QMLTYPES # Now the default INSTALL_QMLTYPES # Now the default diff --git a/src/qml/Qt6QmlDeploySupport.cmake b/src/qml/Qt6QmlDeploySupport.cmake index a230e71409..1b43059cc2 100644 --- a/src/qml/Qt6QmlDeploySupport.cmake +++ b/src/qml/Qt6QmlDeploySupport.cmake @@ -159,6 +159,11 @@ function(_qt_internal_deploy_qml_imports_for_target) # file names, so account for those. There should never be plugin # libraries for more than one QML module in the directory, so we # shouldn't need to worry about matching plugins we don't want. + # + # install_qmldir and install_plugin do not contain $ENV{DESTDIR}, + # whereas dest_qmldir and dest_plugin do. + # The install_ variants are used in file(INSTALL) to avoid double DESTDIR in paths. + # Other code should reference the dest_ variants instead. set(relative_qmldir "${arg_QML_DIR}/${entry_RELATIVEPATH}") if("${CMAKE_INSTALL_PREFIX}" STREQUAL "") set(install_qmldir "./${relative_qmldir}") @@ -180,6 +185,12 @@ function(_qt_internal_deploy_qml_imports_for_target) file(INSTALL "${entry_PATH}/qmldir" DESTINATION "${install_qmldir}") + if(DEFINED __QT_DEPLOY_TARGET_${entry_LINKTARGET}_FILE AND + __QT_DEPLOY_TARGET_${entry_LINKTARGET}_TYPE STREQUAL "STATIC_LIBRARY") + # If the QML plugin is built statically, skip further deployment. + continue() + endif() + if(__QT_DEPLOY_POST_BUILD) # We are being invoked as a post-build step. The plugin might # not exist yet, so we can't even glob for it, let alone copy diff --git a/src/qml/Qt6QmlMacros.cmake b/src/qml/Qt6QmlMacros.cmake index 5352f896f6..fc12af5204 100644 --- a/src/qml/Qt6QmlMacros.cmake +++ b/src/qml/Qt6QmlMacros.cmake @@ -30,8 +30,6 @@ function(qt6_add_qml_module target) NO_CACHEGEN NO_RESOURCE_TARGET_PATH NO_IMPORT_SCAN - # TODO: Remove once all usages have also been removed - SKIP_TYPE_REGISTRATION ENABLE_TYPE_COMPILER # Used to mark modules as having static side effects (i.e. if they install an image provider) @@ -112,12 +110,6 @@ function(qt6_add_qml_module target) ) endif() - if(arg_SKIP_TYPE_REGISTRATION) - message(AUTHOR_WARNING - "SKIP_TYPE_REGISTRATION is no longer used and will be ignored." - ) - endif() - # Mandatory arguments if (NOT arg_URI) message(FATAL_ERROR @@ -3825,9 +3817,30 @@ endif()") # imports deployed to the bundle anyway, the build RPATHs will allow # the regular libraries, frameworks and non-QML plugins to still be # found, even if they are outside the app bundle. + + # Support Xcode, which places the application build dir into a configuration specific + # subdirectory. Override both the deploy prefix and install prefix, because we + # differentiate them in the qml installation implementation due to ENV{DESTDIR} + # handling. + set(deploy_path_suffix "") + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(deploy_path_suffix "/$<CONFIG>") + endif() + + set(target_binary_dir_with_config_prefix + "$<TARGET_PROPERTY:${arg_TARGET},BINARY_DIR>${deploy_path_suffix}") + + set(post_build_install_prefix + "CMAKE_INSTALL_PREFIX=${target_binary_dir_with_config_prefix}") + + set(post_build_deploy_prefix + "QT_DEPLOY_PREFIX=${target_binary_dir_with_config_prefix}") + add_custom_command(TARGET ${arg_TARGET} POST_BUILD COMMAND ${CMAKE_COMMAND} - -D "QT_DEPLOY_PREFIX=$<TARGET_PROPERTY:${arg_TARGET},BINARY_DIR>" + -D "${post_build_install_prefix}" + -D "${post_build_deploy_prefix}" -D "__QT_DEPLOY_IMPL_DIR=${deploy_impl_dir}" -D "__QT_DEPLOY_POST_BUILD=TRUE" -P "${post_build_deploy_script}" diff --git a/src/qml/configure.cmake b/src/qml/configure.cmake index d1ff90bd54..1bc647ff29 100644 --- a/src/qml/configure.cmake +++ b/src/qml/configure.cmake @@ -14,7 +14,7 @@ qt_find_package(LTTngUST PROVIDED_TARGETS LTTng::UST MODULE_NAME qml QMAKE_LIB l qt_find_package(Python REQUIRED) if(Python_Interpreter_FOUND) # Need to make it globally available to the project - set(QT_INTERNAL_DECLARATIVE_PYTHON "${Python_EXECUTABLE}" CACHE STRING "") + set(QT_INTERNAL_DECLARATIVE_PYTHON "${Python_EXECUTABLE}" CACHE STRING "" FORCE) endif() #### Tests diff --git a/src/qml/doc/src/external-resources.qdoc b/src/qml/doc/src/external-resources.qdoc index 091df193a5..ac22729d63 100644 --- a/src/qml/doc/src/external-resources.qdoc +++ b/src/qml/doc/src/external-resources.qdoc @@ -69,3 +69,8 @@ \externalpage https://developer.android.com/reference/java/lang/ClassCastException \title Android: ClassCastException */ +/*! + \externalpage https://developer.android.com/topic/libraries/view-binding + \title Android: View binding +*/ + diff --git a/src/qml/doc/src/javascript/qmlglobalobject.qdoc b/src/qml/doc/src/javascript/qmlglobalobject.qdoc index 15b9996ff3..1bd03fad54 100644 --- a/src/qml/doc/src/javascript/qmlglobalobject.qdoc +++ b/src/qml/doc/src/javascript/qmlglobalobject.qdoc @@ -13,8 +13,8 @@ additional imports: \list \li The \l{QmlGlobalQtObject}{Qt object}: A QML object that offers helper methods and properties specific to the QML environment. -\li \l {Qt::}{qsTr()}, \l {Qt::}{qsTranslate()}, \l {Qt::}{qsTrId()}, \l {Qt::}{qsTrNoOp()}, - \l {Qt::}{qsTranslateNoOp()}, \l {Qt::}{qsTrIdNoOp()} functions: +\li \l {Qt::}{qsTr()}, \l {Qt::}{qsTranslate()}, \l {Qt::}{qsTrId()}, \l {Qt::}{QT_TR_NOOP()()}, + \l {Qt::}{QT_TRANSLATE_NOOP()}, \l {Qt::}{QT_TRID_NOOP()} functions: QML functions that let you translate \l{Mark Strings for Translation} {strings} and \l{Mark Translatable Data Text Strings}{string literals} in the QML environment. diff --git a/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc b/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc index 0fb7d5f039..2b1803042e 100644 --- a/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc +++ b/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc @@ -868,7 +868,7 @@ provided by the client: SquareButton { onDeactivated: console.log("Deactivated!") onActivated: (xPosition, yPosition) => { - console.log(`Activated at {xPosition}, ${yPosition}`) + console.log(`Activated at ${xPosition}, ${yPosition}`) } } \endqml diff --git a/src/qml/doc/src/tools/qtqml-tooling-svgtoqml.qdoc b/src/qml/doc/src/tools/qtqml-tooling-svgtoqml.qdoc index 28d2683ff9..836acc3f6a 100644 --- a/src/qml/doc/src/tools/qtqml-tooling-svgtoqml.qdoc +++ b/src/qml/doc/src/tools/qtqml-tooling-svgtoqml.qdoc @@ -1,4 +1,4 @@ -// Copyright (C) 2023 The Qt Company Ltd. +// Copyright (C) 2024 The Qt Company Ltd. // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only /*! @@ -7,11 +7,86 @@ \brief The SVG to QML converter tool \ingroup qtqml-tooling -svgtoqml is a command line tool shipped with Qt that converts an SVG document +\c svgtoqml is a command line tool shipped with Qt that converts an SVG document to a QML file. This QML file can then be used as a component in Qt Quick -applications. +applications. The \l{Weather Forecast Example} includes multiple QML files that have been generated +using this tool. -\note svgtoqml is currently in a Tech Preview stage. It only supports -a limited subset of what the QtSvg module supports. +\section1 Overview +The \c svgtoqml will convert an SVG file to a QML file which uses Qt Quick primitives. Since +Qt Quick supports scalable vector graphics, the resulting item will be smoothly transformable as far +as this is possible. As a baseline, the tool supports most of the static features of the SVG Tiny 1.2 +profile. Certain additional features are supported, determined on a case-by-case basis. Interactive +features and animations are not supported. + +\section1 Usage +The basic usage of \c svgtoqml is to provide an input file and an output file: +\c{svgtoqml input.svg output.qml}. This will read the \c{input.svg} file and convert it into the +corresponding Qt Quick scene in \c{output.qml}, which can then be used as part of a Qt Quick +application. + +In addition, it supports the following options: + +\table +\header + \li Option + \li Description +\row + \li --copyright-statement <string> + \li Adds <string> as a comment at the beginning of the generated file. +\row + \li --curve-renderer + \li Enables the curve renderer backend for \l{Qt Quick Shapes}. This enables smooth, antialiased + shapes in the scene without multi-sampling, but at some extra cost. +\row + \li --optimize-paths + \li Enables optimization of paths before committing them to the QML file, potentially making + them faster to load and render later. +\row + \li --outline-stroke-mode + \li Stroke the outline (contour) of the filled shape instead of the original path. +\row + \li -t, --type-name <string> + \li In place of \l{Shape}, the output will use the type name <string> instead. This is + enables using a custom item to override the default behavior of \l{Shape} items. +\row + \li -v, --view + \li Display a preview of the Qt Quick item as it will be generated. +\endtable + +\section1 Comparison to other options +There are multiple options for including SVG content in Qt Quick. The following will give an +overview of where \c svgtoqml fits into the story. + +\section2 Comparison to Qt Svg +\l{Qt Svg} is a module which provides a parser and software renderer for SVG files. In addition, it +includes an image loader plugin, so that SVG files can be loaded directly by the \l{Image} element +in Qt Quick. The SVG will then be rasterized and cached at a specified size and redrawing it will +be quite cheap. But zooming into the image without pixelation will involve reloading it at a +different size, which in turn can be expensive. + +\c svgtoqml (and the \l{VectorImage} component) are alternative ways of rendering the same content. +Once loaded into Qt Quick, transforms can be changed while retaining the geometry data needed to +render the scene in GPU memory. Thus, the vector image can be redrawn at different scales with very +little overhead. + +If the image size will not change during the life time of the application, however, loading the +SVG as an \l{Image} will be more efficient. In this case, if the SVG is always rendered at a +small subset of possible sizes, consider pre-rasterizing it to an image format which is more +efficient to load, such as \c PNG. + +\section2 Comparison to VectorImage +The \l{VectorImage} component provides the same basic functionality as \c svgtoqml, but instead of +pregenerating the Qt Quick scene as a QML file, it creates the scene at runtime. This allows loading +SVG files that are not provided at build time and thus allows for more flexibility. Pregenerating +the scenes with \c svgtoqml allows optimizing the scene before it is loaded. Thus, for files that +are available at build time, \c svgtoqml is the preferred option. + +\section2 Comparison to PathSvg +The \l{PathSvg} component is part of the \l{Qt Quick Shapes} module. It provides a way to define +paths with the syntax used by SVG, where the control points of a path are specified as a string. It +does not support loading SVG files, so it is not a direct alternative to \c svgtoqml. If a complex +SVG contains a specific shape needed by the application, then copying this path description into +\l{PathSvg} may be more convenient than generating the full file. */ diff --git a/src/qml/jsapi/qjsengine.cpp b/src/qml/jsapi/qjsengine.cpp index 42a279ca25..8346ef5d84 100644 --- a/src/qml/jsapi/qjsengine.cpp +++ b/src/qml/jsapi/qjsengine.cpp @@ -16,6 +16,7 @@ #include <private/qqmlbuiltinfunctions_p.h> #include <private/qqmldebugconnector_p.h> #include <private/qv4qobjectwrapper_p.h> +#include <private/qv4qmetaobjectwrapper_p.h> #include <private/qv4stackframe_p.h> #include <private/qv4module_p.h> #include <private/qv4symbol_p.h> diff --git a/src/qml/jsapi/qjsmanagedvalue.cpp b/src/qml/jsapi/qjsmanagedvalue.cpp index a4f2f97432..452f991a26 100644 --- a/src/qml/jsapi/qjsmanagedvalue.cpp +++ b/src/qml/jsapi/qjsmanagedvalue.cpp @@ -13,6 +13,7 @@ #include <QtQml/private/qv4urlobject_p.h> #include <QtQml/private/qv4variantobject_p.h> #include <QtQml/private/qv4qobjectwrapper_p.h> +#include <QtQml/private/qv4qmetaobjectwrapper_p.h> #include <QtQml/private/qv4regexpobject_p.h> #include <QtQml/private/qv4dateobject_p.h> #include <QtQml/private/qv4errorobject_p.h> diff --git a/src/qml/jsapi/qjsprimitivevalue.h b/src/qml/jsapi/qjsprimitivevalue.h index 4ba3fd7dc3..3551eca358 100644 --- a/src/qml/jsapi/qjsprimitivevalue.h +++ b/src/qml/jsapi/qjsprimitivevalue.h @@ -355,11 +355,16 @@ public: return leftInt % rightInt; Q_FALLTHROUGH(); } - default: + case Undefined: + case Null: + case Double: + case String: break; } Q_FALLTHROUGH(); - default: + case Undefined: + case Double: + case String: break; } @@ -706,9 +711,18 @@ private: { switch (type()) { case Undefined: return true; + case Null: return false; + case Boolean: return false; + case Integer: return false; case Double: return std::isnan(asDouble()); - default: return false; + case String: return false; } + // GCC 8.x does not treat __builtin_unreachable() as constexpr + #if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900) + Q_UNREACHABLE_RETURN(false); + #else + return false; + #endif } struct QJSPrimitiveValuePrivate diff --git a/src/qml/jsapi/qjsvalue.cpp b/src/qml/jsapi/qjsvalue.cpp index 5d320809dd..f6b97262c3 100644 --- a/src/qml/jsapi/qjsvalue.cpp +++ b/src/qml/jsapi/qjsvalue.cpp @@ -19,6 +19,7 @@ #include <private/qv4mm_p.h> #include <private/qv4jscall_p.h> #include <private/qv4qobjectwrapper_p.h> +#include <private/qv4qmetaobjectwrapper_p.h> #include <private/qv4urlobject_p.h> #include <private/qqmlbuiltins_p.h> diff --git a/src/qml/jsruntime/qv4arraybuffer.cpp b/src/qml/jsruntime/qv4arraybuffer.cpp index f2be552cf8..a49bd32d66 100644 --- a/src/qml/jsruntime/qv4arraybuffer.cpp +++ b/src/qml/jsruntime/qv4arraybuffer.cpp @@ -12,14 +12,14 @@ DEFINE_OBJECT_VTABLE(ArrayBufferCtor); DEFINE_OBJECT_VTABLE(SharedArrayBuffer); DEFINE_OBJECT_VTABLE(ArrayBuffer); -void Heap::SharedArrayBufferCtor::init(QV4::ExecutionContext *scope) +void Heap::SharedArrayBufferCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("SharedArrayBuffer")); + Heap::FunctionObject::init(engine, QStringLiteral("SharedArrayBuffer")); } -void Heap::ArrayBufferCtor::init(QV4::ExecutionContext *scope) +void Heap::ArrayBufferCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("ArrayBuffer")); + Heap::FunctionObject::init(engine, QStringLiteral("ArrayBuffer")); } ReturnedValue SharedArrayBufferCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) diff --git a/src/qml/jsruntime/qv4arraybuffer_p.h b/src/qml/jsruntime/qv4arraybuffer_p.h index aafa3c6335..af1195a947 100644 --- a/src/qml/jsruntime/qv4arraybuffer_p.h +++ b/src/qml/jsruntime/qv4arraybuffer_p.h @@ -25,11 +25,11 @@ namespace QV4 { namespace Heap { struct SharedArrayBufferCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(QV4::ExecutionEngine *engine); }; struct ArrayBufferCtor : SharedArrayBufferCtor { - void init(QV4::ExecutionContext *scope); + void init(QV4::ExecutionEngine *engine); }; struct Q_QML_EXPORT SharedArrayBuffer : Object { diff --git a/src/qml/jsruntime/qv4arrayobject.cpp b/src/qml/jsruntime/qv4arrayobject.cpp index a32017210a..7c9e7034d8 100644 --- a/src/qml/jsruntime/qv4arrayobject.cpp +++ b/src/qml/jsruntime/qv4arrayobject.cpp @@ -14,9 +14,9 @@ using namespace QV4; DEFINE_OBJECT_VTABLE(ArrayCtor); -void Heap::ArrayCtor::init(QV4::ExecutionContext *scope) +void Heap::ArrayCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Array")); + Heap::FunctionObject::init(engine, QStringLiteral("Array")); } ReturnedValue ArrayCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) diff --git a/src/qml/jsruntime/qv4arrayobject_p.h b/src/qml/jsruntime/qv4arrayobject_p.h index b07e27b24f..a68068937f 100644 --- a/src/qml/jsruntime/qv4arrayobject_p.h +++ b/src/qml/jsruntime/qv4arrayobject_p.h @@ -50,7 +50,7 @@ namespace QV4 { namespace Heap { struct ArrayCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(QV4::ExecutionEngine *engine); }; } diff --git a/src/qml/jsruntime/qv4booleanobject.cpp b/src/qml/jsruntime/qv4booleanobject.cpp index 3110ec7992..5c1d50e753 100644 --- a/src/qml/jsruntime/qv4booleanobject.cpp +++ b/src/qml/jsruntime/qv4booleanobject.cpp @@ -8,9 +8,9 @@ using namespace QV4; DEFINE_OBJECT_VTABLE(BooleanCtor); DEFINE_OBJECT_VTABLE(BooleanObject); -void Heap::BooleanCtor::init(QV4::ExecutionContext *scope) +void Heap::BooleanCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Boolean")); + Heap::FunctionObject::init(engine, QStringLiteral("Boolean")); } ReturnedValue BooleanCtor::virtualCallAsConstructor(const FunctionObject *that, const Value *argv, int argc, const Value *newTarget) diff --git a/src/qml/jsruntime/qv4booleanobject_p.h b/src/qml/jsruntime/qv4booleanobject_p.h index e009b0413a..1b2d3914ac 100644 --- a/src/qml/jsruntime/qv4booleanobject_p.h +++ b/src/qml/jsruntime/qv4booleanobject_p.h @@ -25,7 +25,7 @@ namespace QV4 { namespace Heap { struct BooleanCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; } diff --git a/src/qml/jsruntime/qv4context.cpp b/src/qml/jsruntime/qv4context.cpp index 3ae3e5d24c..01f9b4adf3 100644 --- a/src/qml/jsruntime/qv4context.cpp +++ b/src/qml/jsruntime/qv4context.cpp @@ -32,7 +32,7 @@ Heap::CallContext *ExecutionContext::newBlockContext(CppStackFrame *frame, int b Heap::ExecutionContext *outer = static_cast<Heap::ExecutionContext *>(frame->context()->m()); c->outer.set(v4, outer); if (frame->isJSTypesFrame()) { - c->function.set(v4, static_cast<Heap::FunctionObject *>( + c->function.set(v4, static_cast<Heap::JavaScriptFunctionObject *>( Value::fromStaticValue( static_cast<JSTypesStackFrame *>(frame)->jsFrame->function).m())); } else { @@ -74,7 +74,7 @@ Heap::CallContext *ExecutionContext::newCallContext(JSTypesStackFrame *frame) c->init(); c->outer.set(v4, outer); - c->function.set(v4, static_cast<Heap::FunctionObject *>( + c->function.set(v4, static_cast<Heap::JavaScriptFunctionObject *>( Value::fromStaticValue(frame->jsFrame->function).m())); const CompiledData::Function *compiledFunction = function->compiledFunction; diff --git a/src/qml/jsruntime/qv4context_p.h b/src/qml/jsruntime/qv4context_p.h index 82a9472223..48b6e04025 100644 --- a/src/qml/jsruntime/qv4context_p.h +++ b/src/qml/jsruntime/qv4context_p.h @@ -64,7 +64,7 @@ Q_STATIC_ASSERT(offsetof(ExecutionContextData, outer) == 0); Q_STATIC_ASSERT(offsetof(ExecutionContextData, activation) == offsetof(ExecutionContextData, outer) + QT_POINTER_SIZE); #define CallContextMembers(class, Member) \ - Member(class, Pointer, FunctionObject *, function) \ + Member(class, Pointer, JavaScriptFunctionObject *, function) \ Member(class, ValueArray, ValueArray, locals) DECLARE_HEAP_OBJECT(CallContext, ExecutionContext) { diff --git a/src/qml/jsruntime/qv4dataview.cpp b/src/qml/jsruntime/qv4dataview.cpp index f4ca09a127..689eb9232b 100644 --- a/src/qml/jsruntime/qv4dataview.cpp +++ b/src/qml/jsruntime/qv4dataview.cpp @@ -13,9 +13,9 @@ using namespace QV4; DEFINE_OBJECT_VTABLE(DataViewCtor); DEFINE_OBJECT_VTABLE(DataView); -void Heap::DataViewCtor::init(QV4::ExecutionContext *scope) +void Heap::DataViewCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("DataView")); + Heap::FunctionObject::init(engine, QStringLiteral("DataView")); } static uint toIndex(ExecutionEngine *e, const Value &v) diff --git a/src/qml/jsruntime/qv4dataview_p.h b/src/qml/jsruntime/qv4dataview_p.h index ab2e1e589a..b5fa41d964 100644 --- a/src/qml/jsruntime/qv4dataview_p.h +++ b/src/qml/jsruntime/qv4dataview_p.h @@ -24,7 +24,7 @@ namespace QV4 { namespace Heap { struct DataViewCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; #define DataViewMembers(class, Member) \ diff --git a/src/qml/jsruntime/qv4dateobject.cpp b/src/qml/jsruntime/qv4dateobject.cpp index 6b64be3abb..2cb020e495 100644 --- a/src/qml/jsruntime/qv4dateobject.cpp +++ b/src/qml/jsruntime/qv4dateobject.cpp @@ -766,9 +766,9 @@ QDate DateObject::dateTimeToDate(const QDateTime &dateTime) DEFINE_OBJECT_VTABLE(DateCtor); -void Heap::DateCtor::init(QV4::ExecutionContext *scope) +void Heap::DateCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Date")); + Heap::FunctionObject::init(engine, QStringLiteral("Date")); } ReturnedValue DateCtor::virtualCallAsConstructor(const FunctionObject *that, const Value *argv, int argc, const Value *newTarget) diff --git a/src/qml/jsruntime/qv4dateobject_p.h b/src/qml/jsruntime/qv4dateobject_p.h index 7debcff4e9..4c184de897 100644 --- a/src/qml/jsruntime/qv4dateobject_p.h +++ b/src/qml/jsruntime/qv4dateobject_p.h @@ -189,7 +189,7 @@ private: struct DateCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(QV4::ExecutionEngine *engine); }; } diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp index 6b84146866..8450959de4 100644 --- a/src/qml/jsruntime/qv4engine.cpp +++ b/src/qml/jsruntime/qv4engine.cpp @@ -61,6 +61,7 @@ #include "qv4variantobject_p.h" #include "qv4sequenceobject_p.h" #include "qv4qobjectwrapper_p.h" +#include "qv4qmetaobjectwrapper_p.h" #include "qv4memberdata_p.h" #include "qv4arraybuffer_p.h" #include "qv4dataview_p.h" @@ -626,25 +627,23 @@ ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine) ic = newInternalClass(SequencePrototype::staticVTable(), SequencePrototype::defaultPrototype(this)); jsObjects[SequenceProto] = ScopedValue(scope, memoryManager->allocObject<SequencePrototype>(ic->d())); - ExecutionContext *global = rootContext(); - - jsObjects[Object_Ctor] = memoryManager->allocate<ObjectCtor>(global); - jsObjects[String_Ctor] = memoryManager->allocate<StringCtor>(global); - jsObjects[Symbol_Ctor] = memoryManager->allocate<SymbolCtor>(global); - jsObjects[Number_Ctor] = memoryManager->allocate<NumberCtor>(global); - jsObjects[Boolean_Ctor] = memoryManager->allocate<BooleanCtor>(global); - jsObjects[Array_Ctor] = memoryManager->allocate<ArrayCtor>(global); - jsObjects[Function_Ctor] = memoryManager->allocate<FunctionCtor>(global); - jsObjects[GeneratorFunction_Ctor] = memoryManager->allocate<GeneratorFunctionCtor>(global); - jsObjects[Date_Ctor] = memoryManager->allocate<DateCtor>(global); - jsObjects[RegExp_Ctor] = memoryManager->allocate<RegExpCtor>(global); - jsObjects[Error_Ctor] = memoryManager->allocate<ErrorCtor>(global); - jsObjects[EvalError_Ctor] = memoryManager->allocate<EvalErrorCtor>(global); - jsObjects[RangeError_Ctor] = memoryManager->allocate<RangeErrorCtor>(global); - jsObjects[ReferenceError_Ctor] = memoryManager->allocate<ReferenceErrorCtor>(global); - jsObjects[SyntaxError_Ctor] = memoryManager->allocate<SyntaxErrorCtor>(global); - jsObjects[TypeError_Ctor] = memoryManager->allocate<TypeErrorCtor>(global); - jsObjects[URIError_Ctor] = memoryManager->allocate<URIErrorCtor>(global); + jsObjects[Object_Ctor] = memoryManager->allocate<ObjectCtor>(this); + jsObjects[String_Ctor] = memoryManager->allocate<StringCtor>(this); + jsObjects[Symbol_Ctor] = memoryManager->allocate<SymbolCtor>(this); + jsObjects[Number_Ctor] = memoryManager->allocate<NumberCtor>(this); + jsObjects[Boolean_Ctor] = memoryManager->allocate<BooleanCtor>(this); + jsObjects[Array_Ctor] = memoryManager->allocate<ArrayCtor>(this); + jsObjects[Function_Ctor] = memoryManager->allocate<FunctionCtor>(this); + jsObjects[GeneratorFunction_Ctor] = memoryManager->allocate<GeneratorFunctionCtor>(this); + jsObjects[Date_Ctor] = memoryManager->allocate<DateCtor>(this); + jsObjects[RegExp_Ctor] = memoryManager->allocate<RegExpCtor>(this); + jsObjects[Error_Ctor] = memoryManager->allocate<ErrorCtor>(this); + jsObjects[EvalError_Ctor] = memoryManager->allocate<EvalErrorCtor>(this); + jsObjects[RangeError_Ctor] = memoryManager->allocate<RangeErrorCtor>(this); + jsObjects[ReferenceError_Ctor] = memoryManager->allocate<ReferenceErrorCtor>(this); + jsObjects[SyntaxError_Ctor] = memoryManager->allocate<SyntaxErrorCtor>(this); + jsObjects[TypeError_Ctor] = memoryManager->allocate<TypeErrorCtor>(this); + jsObjects[URIError_Ctor] = memoryManager->allocate<URIErrorCtor>(this); jsObjects[IteratorProto] = memoryManager->allocate<IteratorPrototype>(); ic = newInternalClass(ForInIteratorPrototype::staticVTable(), iteratorPrototype()); @@ -662,9 +661,9 @@ ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine) // url // - jsObjects[Url_Ctor] = memoryManager->allocate<UrlCtor>(global); + jsObjects[Url_Ctor] = memoryManager->allocate<UrlCtor>(this); jsObjects[UrlProto] = memoryManager->allocate<UrlPrototype>(); - jsObjects[UrlSearchParams_Ctor] = memoryManager->allocate<UrlSearchParamsCtor>(global); + jsObjects[UrlSearchParams_Ctor] = memoryManager->allocate<UrlSearchParamsCtor>(this); jsObjects[UrlSearchParamsProto] = memoryManager->allocate<UrlSearchParamsPrototype>(); str = newString(QStringLiteral("get [Symbol.species]")); @@ -702,19 +701,19 @@ ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine) sequencePrototype()->cast<SequencePrototype>()->init(); - jsObjects[WeakMap_Ctor] = memoryManager->allocate<WeakMapCtor>(global); + jsObjects[WeakMap_Ctor] = memoryManager->allocate<WeakMapCtor>(this); jsObjects[WeakMapProto] = memoryManager->allocate<WeakMapPrototype>(); static_cast<WeakMapPrototype *>(weakMapPrototype())->init(this, weakMapCtor()); - jsObjects[Map_Ctor] = memoryManager->allocate<MapCtor>(global); + jsObjects[Map_Ctor] = memoryManager->allocate<MapCtor>(this); jsObjects[MapProto] = memoryManager->allocate<MapPrototype>(); static_cast<MapPrototype *>(mapPrototype())->init(this, mapCtor()); - jsObjects[WeakSet_Ctor] = memoryManager->allocate<WeakSetCtor>(global); + jsObjects[WeakSet_Ctor] = memoryManager->allocate<WeakSetCtor>(this); jsObjects[WeakSetProto] = memoryManager->allocate<WeakSetPrototype>(); static_cast<WeakSetPrototype *>(weakSetPrototype())->init(this, weakSetCtor()); - jsObjects[Set_Ctor] = memoryManager->allocate<SetCtor>(global); + jsObjects[Set_Ctor] = memoryManager->allocate<SetCtor>(this); jsObjects[SetProto] = memoryManager->allocate<SetPrototype>(); static_cast<SetPrototype *>(setPrototype())->init(this, setCtor()); @@ -722,33 +721,33 @@ ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine) // promises // - jsObjects[Promise_Ctor] = memoryManager->allocate<PromiseCtor>(global); + jsObjects[Promise_Ctor] = memoryManager->allocate<PromiseCtor>(this); jsObjects[PromiseProto] = memoryManager->allocate<PromisePrototype>(); static_cast<PromisePrototype *>(promisePrototype())->init(this, promiseCtor()); // typed arrays - jsObjects[SharedArrayBuffer_Ctor] = memoryManager->allocate<SharedArrayBufferCtor>(global); + jsObjects[SharedArrayBuffer_Ctor] = memoryManager->allocate<SharedArrayBufferCtor>(this); jsObjects[SharedArrayBufferProto] = memoryManager->allocate<SharedArrayBufferPrototype>(); static_cast<SharedArrayBufferPrototype *>(sharedArrayBufferPrototype())->init(this, sharedArrayBufferCtor()); - jsObjects[ArrayBuffer_Ctor] = memoryManager->allocate<ArrayBufferCtor>(global); + jsObjects[ArrayBuffer_Ctor] = memoryManager->allocate<ArrayBufferCtor>(this); jsObjects[ArrayBufferProto] = memoryManager->allocate<ArrayBufferPrototype>(); static_cast<ArrayBufferPrototype *>(arrayBufferPrototype())->init(this, arrayBufferCtor()); - jsObjects[DataView_Ctor] = memoryManager->allocate<DataViewCtor>(global); + jsObjects[DataView_Ctor] = memoryManager->allocate<DataViewCtor>(this); jsObjects[DataViewProto] = memoryManager->allocate<DataViewPrototype>(); static_cast<DataViewPrototype *>(dataViewPrototype())->init(this, dataViewCtor()); jsObjects[ValueTypeProto] = (Heap::Base *) nullptr; jsObjects[SignalHandlerProto] = (Heap::Base *) nullptr; - jsObjects[IntrinsicTypedArray_Ctor] = memoryManager->allocate<IntrinsicTypedArrayCtor>(global); + jsObjects[IntrinsicTypedArray_Ctor] = memoryManager->allocate<IntrinsicTypedArrayCtor>(this); jsObjects[IntrinsicTypedArrayProto] = memoryManager->allocate<IntrinsicTypedArrayPrototype>(); static_cast<IntrinsicTypedArrayPrototype *>(intrinsicTypedArrayPrototype()) ->init(this, static_cast<IntrinsicTypedArrayCtor *>(intrinsicTypedArrayCtor())); for (int i = 0; i < NTypedArrayTypes; ++i) { - static_cast<Value &>(typedArrayCtors[i]) = memoryManager->allocate<TypedArrayCtor>(global, Heap::TypedArray::Type(i)); + static_cast<Value &>(typedArrayCtors[i]) = memoryManager->allocate<TypedArrayCtor>(this, Heap::TypedArray::Type(i)); static_cast<Value &>(typedArrayPrototype[i]) = memoryManager->allocate<TypedArrayPrototype>(Heap::TypedArray::Type(i)); typedArrayPrototype[i].as<TypedArrayPrototype>()->init(this, static_cast<TypedArrayCtor *>(typedArrayCtors[i].as<Object>())); } @@ -795,14 +794,14 @@ ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine) globalObject->defineDefaultProperty(QStringLiteral("Math"), (o = memoryManager->allocate<MathObject>())); globalObject->defineDefaultProperty(QStringLiteral("JSON"), (o = memoryManager->allocate<JsonObject>())); globalObject->defineDefaultProperty(QStringLiteral("Reflect"), (o = memoryManager->allocate<Reflect>())); - globalObject->defineDefaultProperty(QStringLiteral("Proxy"), (o = memoryManager->allocate<Proxy>(rootContext()))); + globalObject->defineDefaultProperty(QStringLiteral("Proxy"), (o = memoryManager->allocate<Proxy>(this))); globalObject->defineReadonlyProperty(QStringLiteral("undefined"), Value::undefinedValue()); globalObject->defineReadonlyProperty(QStringLiteral("NaN"), Value::fromDouble(std::numeric_limits<double>::quiet_NaN())); globalObject->defineReadonlyProperty(QStringLiteral("Infinity"), Value::fromDouble(Q_INFINITY)); - jsObjects[Eval_Function] = memoryManager->allocate<EvalFunction>(global); + jsObjects[Eval_Function] = memoryManager->allocate<EvalFunction>(this); globalObject->defineDefaultProperty(QStringLiteral("eval"), *evalFunction()); // ES6: 20.1.2.12 & 20.1.2.13: @@ -831,7 +830,9 @@ ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine) globalObject->defineDefaultProperty(QStringLiteral("escape"), GlobalFunctions::method_escape, 1); globalObject->defineDefaultProperty(QStringLiteral("unescape"), GlobalFunctions::method_unescape, 1); - ScopedFunctionObject t(scope, memoryManager->allocate<FunctionObject>(rootContext(), nullptr, ::throwTypeError)); + ScopedFunctionObject t( + scope, + memoryManager->allocate<DynamicFunctionObject>(this, nullptr, ::throwTypeError)); t->defineReadonlyProperty(id_length(), Value::fromInt32(0)); t->setInternalClass(t->internalClass()->cryopreserved()); jsObjects[ThrowerObject] = t; diff --git a/src/qml/jsruntime/qv4errorobject.cpp b/src/qml/jsruntime/qv4errorobject.cpp index 35b5952d38..02145a0243 100644 --- a/src/qml/jsruntime/qv4errorobject.cpp +++ b/src/qml/jsruntime/qv4errorobject.cpp @@ -182,14 +182,14 @@ DEFINE_OBJECT_VTABLE(SyntaxErrorCtor); DEFINE_OBJECT_VTABLE(TypeErrorCtor); DEFINE_OBJECT_VTABLE(URIErrorCtor); -void Heap::ErrorCtor::init(QV4::ExecutionContext *scope) +void Heap::ErrorCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Error")); + Heap::FunctionObject::init(engine, QStringLiteral("Error")); } -void Heap::ErrorCtor::init(QV4::ExecutionContext *scope, const QString &name) +void Heap::ErrorCtor::init(QV4::ExecutionEngine *engine, const QString &name) { - Heap::FunctionObject::init(scope, name); + Heap::FunctionObject::init(engine, name); } ReturnedValue ErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) @@ -203,9 +203,9 @@ ReturnedValue ErrorCtor::virtualCall(const FunctionObject *f, const Value *, con return f->callAsConstructor(argv, argc); } -void Heap::EvalErrorCtor::init(QV4::ExecutionContext *scope) +void Heap::EvalErrorCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("EvalError")); + Heap::FunctionObject::init(engine, QStringLiteral("EvalError")); } ReturnedValue EvalErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) @@ -214,9 +214,9 @@ ReturnedValue EvalErrorCtor::virtualCallAsConstructor(const FunctionObject *f, c return ErrorObject::create<EvalErrorObject>(f->engine(), v, newTarget)->asReturnedValue(); } -void Heap::RangeErrorCtor::init(QV4::ExecutionContext *scope) +void Heap::RangeErrorCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("RangeError")); + Heap::FunctionObject::init(engine, QStringLiteral("RangeError")); } ReturnedValue RangeErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) @@ -225,9 +225,9 @@ ReturnedValue RangeErrorCtor::virtualCallAsConstructor(const FunctionObject *f, return ErrorObject::create<RangeErrorObject>(f->engine(), v, newTarget)->asReturnedValue(); } -void Heap::ReferenceErrorCtor::init(QV4::ExecutionContext *scope) +void Heap::ReferenceErrorCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("ReferenceError")); + Heap::FunctionObject::init(engine, QStringLiteral("ReferenceError")); } ReturnedValue ReferenceErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) @@ -236,9 +236,9 @@ ReturnedValue ReferenceErrorCtor::virtualCallAsConstructor(const FunctionObject return ErrorObject::create<ReferenceErrorObject>(f->engine(), v, newTarget)->asReturnedValue(); } -void Heap::SyntaxErrorCtor::init(QV4::ExecutionContext *scope) +void Heap::SyntaxErrorCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("SyntaxError")); + Heap::FunctionObject::init(engine, QStringLiteral("SyntaxError")); } ReturnedValue SyntaxErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) @@ -247,9 +247,9 @@ ReturnedValue SyntaxErrorCtor::virtualCallAsConstructor(const FunctionObject *f, return ErrorObject::create<SyntaxErrorObject>(f->engine(), v, newTarget)->asReturnedValue(); } -void Heap::TypeErrorCtor::init(QV4::ExecutionContext *scope) +void Heap::TypeErrorCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("TypeError")); + Heap::FunctionObject::init(engine, QStringLiteral("TypeError")); } ReturnedValue TypeErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) @@ -258,9 +258,9 @@ ReturnedValue TypeErrorCtor::virtualCallAsConstructor(const FunctionObject *f, c return ErrorObject::create<TypeErrorObject>(f->engine(), v, newTarget)->asReturnedValue(); } -void Heap::URIErrorCtor::init(QV4::ExecutionContext *scope) +void Heap::URIErrorCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("URIError")); + Heap::FunctionObject::init(engine, QStringLiteral("URIError")); } ReturnedValue URIErrorCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) diff --git a/src/qml/jsruntime/qv4errorobject_p.h b/src/qml/jsruntime/qv4errorobject_p.h index 541f5cae36..f9adbb443b 100644 --- a/src/qml/jsruntime/qv4errorobject_p.h +++ b/src/qml/jsruntime/qv4errorobject_p.h @@ -79,32 +79,32 @@ struct URIErrorObject : ErrorObject { }; struct ErrorCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); - void init(QV4::ExecutionContext *scope, const QString &name); + void init(ExecutionEngine *engine); + void init(ExecutionEngine *engine, const QString &name); }; struct EvalErrorCtor : ErrorCtor { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct RangeErrorCtor : ErrorCtor { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct ReferenceErrorCtor : ErrorCtor { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct SyntaxErrorCtor : ErrorCtor { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct TypeErrorCtor : ErrorCtor { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct URIErrorCtor : ErrorCtor { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; } diff --git a/src/qml/jsruntime/qv4functionobject.cpp b/src/qml/jsruntime/qv4functionobject.cpp index ab6a34435f..e9f91fbc06 100644 --- a/src/qml/jsruntime/qv4functionobject.cpp +++ b/src/qml/jsruntime/qv4functionobject.cpp @@ -30,84 +30,57 @@ using namespace QV4; DEFINE_OBJECT_VTABLE(FunctionObject); -void Heap::FunctionObject::init(QV4::ExecutionContext *scope, QV4::String *name, - VTable::Call call, VTable::CallWithMetaTypes callWithMetaTypes) +void Heap::FunctionObject::init(QV4::ExecutionEngine *engine, QV4::String *name) { - jsCall = call; - jsCallWithMetaTypes = callWithMetaTypes; - jsConstruct = nullptr; - Object::init(); - this->scope.set(scope->engine(), scope->d()); - Scope s(scope->engine()); + Scope s(engine); ScopedFunctionObject f(s, this); if (name) f->setName(name); } -void Heap::FunctionObject::init(QV4::ExecutionContext *scope, QV4::String *name) +void Heap::FunctionObject::init(QV4::ExecutionEngine *engine, const QString &name) { - ExecutionEngine *e = scope->engine(); - - jsCall = vtable()->call; - jsCallWithMetaTypes = vtable()->callWithMetaTypes; - jsConstruct = vtable()->callAsConstructor; - - Object::init(); - this->scope.set(scope->engine(), scope->d()); - Scope s(e); - ScopedFunctionObject f(s, this); - if (name) - f->setName(name); + Scope valueScope(engine); + ScopedString s(valueScope, engine->newString(name)); + init(engine, s); } - - -void Heap::FunctionObject::init(QV4::ExecutionContext *scope, Function *function, QV4::String *n) -{ - jsCall = vtable()->call; - jsCallWithMetaTypes = vtable()->callWithMetaTypes; - jsConstruct = vtable()->callAsConstructor; - - Object::init(); - setFunction(function); - this->scope.set(scope->engine(), scope->d()); - Scope s(scope->engine()); - ScopedString name(s, n ? n->d() : function->name()); - ScopedFunctionObject f(s, this); - if (name) - f->setName(name); -} - -void Heap::FunctionObject::init(QV4::ExecutionContext *scope, const QString &name) +void Heap::FunctionObject::init() { - Scope valueScope(scope); - ScopedString s(valueScope, valueScope.engine->newString(name)); - init(scope, s); + init(internalClass->engine, static_cast<QV4::String *>(nullptr)); } -void Heap::FunctionObject::init() +void Heap::JavaScriptFunctionObject::init( + QV4::ExecutionContext *scope, Function *function, QV4::String *n) { - jsCall = vtable()->call; - jsCallWithMetaTypes = vtable()->callWithMetaTypes; - jsConstruct = vtable()->callAsConstructor; - - Object::init(); - this->scope.set(internalClass->engine, internalClass->engine->rootContext()->d()); + Q_ASSERT(n || function); + Scope s(scope->engine()); + ScopedString name(s, n ? n->d() : function->name()); + FunctionObject::init(s.engine, name); + this->scope.set(s.engine, scope->d()); + setFunction(function); } -void Heap::FunctionObject::setFunction(Function *f) +void Heap::JavaScriptFunctionObject::setFunction(Function *f) { if (f) { function = f; function->executableCompilationUnit()->addref(); } } -void Heap::FunctionObject::destroy() +void Heap::JavaScriptFunctionObject::destroy() { if (function) function->executableCompilationUnit()->release(); - Object::destroy(); + FunctionObject::destroy(); +} + +void Heap::DynamicFunctionObject::init( + QV4::ExecutionEngine *engine, QV4::String *name, VTable::Call call) +{ + FunctionObject::init(engine, name); + jsCall = call; } void FunctionObject::createDefaultPrototypeProperty(uint protoConstructorSlot) @@ -121,32 +94,29 @@ void FunctionObject::createDefaultPrototypeProperty(uint protoConstructorSlot) defineDefaultProperty(s.engine->id_prototype(), proto, Attr_NotEnumerable|Attr_NotConfigurable); } -void FunctionObject::call(QObject *thisObject, void **a, const QMetaType *types, int argc) +ReturnedValue FunctionObject::name() const { - if (const auto callWithMetaTypes = d()->jsCallWithMetaTypes) { - callWithMetaTypes(this, thisObject, a, types, argc); - return; - } - - QV4::convertAndCall(engine(), thisObject, a, types, argc, - [this](const Value *thisObject, const Value *argv, int argc) { - return call(thisObject, argv, argc); - }); + return get(engine()->id_name()); } -ReturnedValue FunctionObject::name() const +ReturnedValue FunctionObject::failCall() const { - return get(scope()->internalClass->engine->id_name()); + return engine()->throwTypeError(QStringLiteral("Function can only be called with |new|.")); } -ReturnedValue FunctionObject::virtualCall(const FunctionObject *, const Value *, const Value *, int) +ReturnedValue FunctionObject::failCallAsConstructor() const { - return Encode::undefined(); + return engine()->throwTypeError(QStringLiteral("Function is not a constructor.")); } -void FunctionObject::virtualCallWithMetaTypes( - const FunctionObject *, QObject *, void **, const QMetaType *, int) +void FunctionObject::virtualConvertAndCall( + const FunctionObject *f, QObject *thisObject, + void **argv, const QMetaType *types, int argc) { + QV4::convertAndCall(f->engine(), thisObject, argv, types, argc, + [f](const Value *thisObject, const Value *argv, int argc) { + return f->call(thisObject, argv, argc); + }); } Heap::FunctionObject *FunctionObject::createScriptFunction(ExecutionContext *scope, Function *function) @@ -156,15 +126,20 @@ Heap::FunctionObject *FunctionObject::createScriptFunction(ExecutionContext *sco return scope->engine()->memoryManager->allocate<ScriptFunction>(scope, function); } -Heap::FunctionObject *FunctionObject::createConstructorFunction(ExecutionContext *scope, Function *function, Object *homeObject, bool isDerivedConstructor) +Heap::FunctionObject *FunctionObject::createConstructorFunction( + ExecutionContext *scope, Function *function, Object *homeObject, bool isDerivedConstructor) { + QV4::ExecutionEngine *engine = scope->engine(); if (!function) { - Heap::DefaultClassConstructorFunction *c = scope->engine()->memoryManager->allocate<DefaultClassConstructorFunction>(scope); + Heap::DefaultClassConstructorFunction *c + = engine->memoryManager->allocate<DefaultClassConstructorFunction>(scope); c->isDerivedConstructor = isDerivedConstructor; return c; } - Heap::ConstructorFunction *c = scope->engine()->memoryManager->allocate<ConstructorFunction>(scope, function); - c->homeObject.set(scope->engine(), homeObject->d()); + + Heap::ConstructorFunction *c + = engine->memoryManager->allocate<ConstructorFunction>(scope, function); + c->homeObject.set(engine, homeObject->d()); c->isDerivedConstructor = isDerivedConstructor; return c; } @@ -183,7 +158,8 @@ Heap::FunctionObject *FunctionObject::createBuiltinFunction(ExecutionEngine *eng if (!name) name = engine->newString(QChar::fromLatin1('[') + QStringView{nameOrSymbol->toQString()}.mid(1) + QChar::fromLatin1(']')); - ScopedFunctionObject function(scope, engine->memoryManager->allocate<FunctionObject>(engine->rootContext(), name, code)); + ScopedFunctionObject function( + scope, engine->memoryManager->allocate<DynamicFunctionObject>(engine, name, code)); function->defineReadonlyConfigurableProperty(engine->id_length(), Value::fromInt32(argumentCount)); return function->d(); } @@ -199,16 +175,29 @@ ReturnedValue FunctionObject::getHomeObject() const return Encode::undefined(); } -QQmlSourceLocation FunctionObject::sourceLocation() const +DEFINE_OBJECT_VTABLE(JavaScriptFunctionObject); + +QQmlSourceLocation JavaScriptFunctionObject::sourceLocation() const { return d()->function->sourceLocation(); } +DEFINE_OBJECT_VTABLE(DynamicFunctionObject); + +ReturnedValue DynamicFunctionObject::virtualCall( + const FunctionObject *f, const Value *thisObject, const Value *argv, int argc) { + Heap::DynamicFunctionObject *d = static_cast<const DynamicFunctionObject *>(f)->d(); + if (d->jsCall) + return d->jsCall(f, thisObject, argv, argc); + return d->internalClass->engine->throwTypeError( + QStringLiteral("Function can only be called with |new|.")); +} + DEFINE_OBJECT_VTABLE(FunctionCtor); -void Heap::FunctionCtor::init(QV4::ExecutionContext *scope) +void Heap::FunctionCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Function")); + Heap::FunctionObject::init(engine, QStringLiteral("Function")); } // 15.3.2 @@ -311,6 +300,12 @@ void FunctionPrototype::init(ExecutionEngine *engine, Object *ctor) defineDefaultProperty(engine->symbol_hasInstance(), method_hasInstance, 1, Attr_ReadOnly); } +ReturnedValue FunctionPrototype::virtualCall( + const FunctionObject *, const Value *, const Value *, int) +{ + return Encode::undefined(); +} + ReturnedValue FunctionPrototype::method_toString(const FunctionObject *b, const Value *thisObject, const Value *, int) { ExecutionEngine *v4 = b->engine(); @@ -427,10 +422,13 @@ ReturnedValue FunctionPrototype::method_bind(const FunctionObject *b, const Valu boundArgs->set(scope.engine, i, argv[i + 1]); } - ScopedContext ctx(scope, target->scope()); - Scoped<BoundFunction> bound(scope, BoundFunction::create(ctx, target, boundThis, boundArgs)); - bound->d()->setFunction(target->function()); - return bound->asReturnedValue(); + if (target->isConstructor()) { + return scope.engine->memoryManager->allocate<BoundConstructor>(target, boundThis, boundArgs) + ->asReturnedValue(); + } + + return scope.engine->memoryManager->allocate<BoundFunction>(target, boundThis, boundArgs) + ->asReturnedValue(); } ReturnedValue FunctionPrototype::method_hasInstance(const FunctionObject *, const Value *thisObject, const Value *argv, int argc) @@ -490,7 +488,9 @@ DEFINE_OBJECT_VTABLE(ArrowFunction); void ArrowFunction::virtualCallWithMetaTypes(const FunctionObject *fo, QObject *thisObject, void **a, const QMetaType *types, int argc) { - if (fo->function()->kind != Function::AotCompiled) { + const ArrowFunction *self = static_cast<const ArrowFunction *>(fo); + Function *function = self->function(); + if (function->kind != Function::AotCompiled) { QV4::convertAndCall(fo->engine(), thisObject, a, types, argc, [fo](const Value *thisObject, const Value *argv, int argc) { return ArrowFunction::virtualCall(fo, thisObject, argv, argc); @@ -499,16 +499,17 @@ void ArrowFunction::virtualCallWithMetaTypes(const FunctionObject *fo, QObject * } QV4::Scope scope(fo->engine()); - QV4::Scoped<ExecutionContext> context(scope, fo->scope()); + QV4::Scoped<ExecutionContext> context(scope, self->scope()); MetaTypesStackFrame frame; - frame.init(fo->function(), thisObject, context, a, types, argc); + frame.init(function, thisObject, context, a, types, argc); frame.push(scope.engine); Moth::VME::exec(&frame, scope.engine); frame.pop(scope.engine); } -static ReturnedValue qfoDoCall(const QV4::FunctionObject *fo, const QV4::Value *thisObject, - const QV4::Value *argv, int argc) +static ReturnedValue qfoDoCall( + const QV4::JavaScriptFunctionObject *fo, const QV4::Value *thisObject, + const QV4::Value *argv, int argc) { ExecutionEngine *engine = fo->engine(); JSTypesStackFrame frame; @@ -535,7 +536,8 @@ static ReturnedValue qfoDoCall(const QV4::FunctionObject *fo, const QV4::Value * ReturnedValue ArrowFunction::virtualCall(const QV4::FunctionObject *fo, const Value *thisObject, const QV4::Value *argv, int argc) { - Function *function = fo->function(); + const ArrowFunction *self = static_cast<const ArrowFunction *>(fo); + Function *function = self->function(); switch (function->kind) { case Function::AotCompiled: return QV4::convertAndCall( @@ -546,34 +548,24 @@ ReturnedValue ArrowFunction::virtualCall(const QV4::FunctionObject *fo, const Va case Function::JsTyped: return QV4::coerceAndCall( fo->engine(), &function->jsTypedFunction, function->compiledFunction, argv, argc, - [fo, thisObject](const Value *argv, int argc) { - return qfoDoCall(fo, thisObject, argv, argc); + [self, thisObject](const Value *argv, int argc) { + return qfoDoCall(self, thisObject, argv, argc); }); default: break; } - return qfoDoCall(fo, thisObject, argv, argc); + return qfoDoCall(self, thisObject, argv, argc); } void Heap::ArrowFunction::init(QV4::ExecutionContext *scope, Function *function, QV4::String *n) { - FunctionObject::init(); - this->scope.set(scope->engine(), scope->d()); - - setFunction(function); Q_ASSERT(function); + JavaScriptFunctionObject::init(scope, function, n); Scope s(scope); - ScopedFunctionObject f(s, this); - - ScopedString name(s, n ? n->d() : function->name()); - if (name) - f->setName(name); - Q_ASSERT(internalClass && internalClass->verifyIndex(s.engine->id_length()->propertyKey(), Index_Length)); setProperty(s.engine, Index_Length, Value::fromInt32(int(function->compiledFunction->length))); - canBeTailCalled = true; } void Heap::ScriptFunction::init(QV4::ExecutionContext *scope, Function *function) @@ -586,6 +578,13 @@ void Heap::ScriptFunction::init(QV4::ExecutionContext *scope, Function *function f->createDefaultPrototypeProperty(Heap::FunctionObject::Index_ProtoConstructor); } +void Heap::DefaultClassConstructorFunction::init(QV4::ExecutionContext *scope) +{ + Scope s(scope->engine()); + FunctionObject::init(s.engine, nullptr); + this->scope.set(s.engine, scope->d()); +} + Heap::InternalClass *ScriptFunction::classForConstructor() const { Scope scope(engine()); @@ -613,8 +612,8 @@ ReturnedValue ConstructorFunction::virtualCallAsConstructor(const FunctionObject ExecutionEngine *v4 = f->engine(); JSTypesStackFrame frame; - frame.init(f->function(), argv, argc); - frame.setupJSFrame(v4->jsStackTop, *f, f->scope(), + frame.init(c->function(), argv, argc); + frame.setupJSFrame(v4->jsStackTop, *f, c->scope(), Value::emptyValue(), newTarget ? *newTarget : Value::undefinedValue()); @@ -668,7 +667,7 @@ ReturnedValue DefaultClassConstructorFunction::virtualCallAsConstructor(const Fu JSTypesStackFrame frame; frame.init(nullptr, argv, argc); - frame.setupJSFrame(v4->jsStackTop, *f, f->scope(), + frame.setupJSFrame(v4->jsStackTop, *f, c->scope(), Value::undefinedValue(), newTarget ? *newTarget : Value::undefinedValue(), argc, argc); @@ -705,33 +704,39 @@ DEFINE_OBJECT_VTABLE(IndexedBuiltinFunction); DEFINE_OBJECT_VTABLE(BoundFunction); -void Heap::BoundFunction::init(QV4::ExecutionContext *scope, QV4::FunctionObject *target, - const Value &boundThis, QV4::MemberData *boundArgs) +void Heap::BoundFunction::init( + QV4::FunctionObject *target, const Value &boundThis, QV4::MemberData *boundArgs) { - Scope s(scope); - Heap::FunctionObject::init(scope, QStringLiteral("__bound function__")); + ExecutionEngine *engine = target->engine(); + Scope s(engine); + ScopedString name(s, engine->newString(QStringLiteral("__bound function__"))); + if (auto *js = target->as<QV4::JavaScriptFunctionObject>()) { + ScopedContext ctx(s, js->scope()); + JavaScriptFunctionObject::init(ctx, js->function(), name); + } else { + Q_ASSERT(name); + JavaScriptFunctionObject::init(engine->rootContext(), nullptr, name); + } + this->target.set(s.engine, target->d()); this->boundArgs.set(s.engine, boundArgs ? boundArgs->d() : nullptr); - this->boundThis.set(scope->engine(), boundThis); - - if (!target->isConstructor()) - jsConstruct = nullptr; + this->boundThis.set(s.engine, boundThis); ScopedObject f(s, this); - ScopedValue l(s, target->get(s.engine->id_length())); + ScopedValue l(s, target->get(engine->id_length())); int len = l->toUInt32(); if (boundArgs) len -= boundArgs->size(); if (len < 0) len = 0; - f->defineReadonlyConfigurableProperty(s.engine->id_length(), Value::fromInt32(len)); + f->defineReadonlyConfigurableProperty(engine->id_length(), Value::fromInt32(len)); ScopedProperty pd(s); - pd->value = s.engine->thrower(); - pd->set = s.engine->thrower(); - f->insertMember(s.engine->id_arguments(), pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable); - f->insertMember(s.engine->id_caller(), pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable); + pd->value = engine->thrower(); + pd->set = engine->thrower(); + f->insertMember(engine->id_arguments(), pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable); + f->insertMember(engine->id_caller(), pd, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable); } ReturnedValue BoundFunction::virtualCall(const FunctionObject *fo, const Value *, const Value *argv, int argc) @@ -755,7 +760,10 @@ ReturnedValue BoundFunction::virtualCall(const FunctionObject *fo, const Value * return checkedResult(v4, target->call(jsCallData)); } -ReturnedValue BoundFunction::virtualCallAsConstructor(const FunctionObject *fo, const Value *argv, int argc, const Value *) +DEFINE_OBJECT_VTABLE(BoundConstructor); + +ReturnedValue BoundConstructor::virtualCallAsConstructor( + const FunctionObject *fo, const Value *argv, int argc, const Value *) { const BoundFunction *f = static_cast<const BoundFunction *>(fo); Scope scope(f->engine()); diff --git a/src/qml/jsruntime/qv4functionobject_p.h b/src/qml/jsruntime/qv4functionobject_p.h index 573848f62a..f4a2935b5a 100644 --- a/src/qml/jsruntime/qv4functionobject_p.h +++ b/src/qml/jsruntime/qv4functionobject_p.h @@ -28,36 +28,41 @@ namespace QV4 { struct IndexedBuiltinFunction; struct JSCallData; -namespace Heap { - +// A FunctionObject is generally something that can be called, either with a JavaScript +// signature (QV4::Value etc) or with a C++ signature (QMetaType etc). For this, it has +// the Call and CallWithMetaTypes VTable entries. +// Some FunctionObjects need to select the actual implementation of the call at run time. +// This comese in two flavors: +// 1. The implementation is a JavaScript function. For these we have +// JavaScriptFunctionObject that holds a QV4::Function member to defer the call to. +// 2. The implementation is a C++ function. For these we have DynamicFunctionObject that +// holds another Call member in the heap object to defer the call to. +// In addition, a FunctionObject may want to be called as constructor. For this we have +// another VTable entry and a flag in the heap object. -#define FunctionObjectMembers(class, Member) \ - Member(class, Pointer, ExecutionContext *, scope) \ - Member(class, NoMark, Function *, function) \ - Member(class, NoMark, VTable::Call, jsCall) \ - Member(class, NoMark, VTable::CallAsConstructor, jsConstruct) \ - Member(class, NoMark, VTable::CallWithMetaTypes, jsCallWithMetaTypes) \ - Member(class, NoMark, bool, canBeTailCalled) +namespace Heap { +#define FunctionObjectMembers(class, Member) DECLARE_HEAP_OBJECT(FunctionObject, Object) { - DECLARE_MARKOBJECTS(FunctionObject) enum { Index_ProtoConstructor = 0, Index_Prototype = 0, Index_HasInstance = 1, }; - bool isConstructor() const { - return jsConstruct != nullptr; - } - - Q_QML_EXPORT void init( - QV4::ExecutionContext *scope, QV4::String *name, - VTable::Call call, VTable::CallWithMetaTypes callWithMetaTypes = nullptr); - Q_QML_EXPORT void init(QV4::ExecutionContext *scope, QV4::String *name = nullptr); - Q_QML_EXPORT void init(QV4::ExecutionContext *scope, QV4::Function *function, QV4::String *n = nullptr); - Q_QML_EXPORT void init(QV4::ExecutionContext *scope, const QString &name); + Q_QML_EXPORT void init(QV4::ExecutionEngine *engine, QV4::String *name = nullptr); + Q_QML_EXPORT void init(QV4::ExecutionEngine *engine, const QString &name); Q_QML_EXPORT void init(); +}; + +#define JavaScriptFunctionObjectMembers(class, Member) \ + Member(class, Pointer, ExecutionContext *, scope) \ + Member(class, NoMark, Function *, function) + +DECLARE_HEAP_OBJECT(JavaScriptFunctionObject, FunctionObject) { + DECLARE_MARKOBJECTS(JavaScriptFunctionObject) + + void init(QV4::ExecutionContext *scope, QV4::Function *function, QV4::String *n = nullptr); Q_QML_EXPORT void destroy(); void setFunction(Function *f); @@ -66,8 +71,18 @@ DECLARE_HEAP_OBJECT(FunctionObject, Object) { unsigned int varCount() { return function ? function->compiledFunction->nLocals : 0; } }; +#define DynamicFunctionObjectMembers(class, Member) \ + Member(class, NoMark, VTable::Call, jsCall) + +DECLARE_HEAP_OBJECT(DynamicFunctionObject, FunctionObject) { + // NB: We might add a CallWithMetaTypes member to this struct and implement our + // builtins with metatypes, to be called from C++ code. This would make them + // available to qmlcachegen's C++ code generation. + void init(ExecutionEngine *engine, QV4::String *name, VTable::Call call); +}; + struct FunctionCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(QV4::ExecutionEngine *engine); }; struct FunctionPrototype : FunctionObject { @@ -76,12 +91,12 @@ struct FunctionPrototype : FunctionObject { // A function object with an additional index into a list. // Used by Models to refer to property roles. -struct IndexedBuiltinFunction : FunctionObject { - inline void init(QV4::ExecutionContext *scope, qsizetype index, VTable::Call call); +struct IndexedBuiltinFunction : DynamicFunctionObject { + inline void init(QV4::ExecutionEngine *engine, qsizetype index, VTable::Call call); qsizetype index; }; -struct ArrowFunction : FunctionObject { +struct ArrowFunction : JavaScriptFunctionObject { enum { Index_Name = Index_HasInstance + 1, Index_Length @@ -116,9 +131,15 @@ DECLARE_HEAP_OBJECT(ConstructorFunction, ScriptFunction) { bool isDerivedConstructor; }; -struct DefaultClassConstructorFunction : FunctionObject -{ +#define DefaultClassConstructorFunctionMembers(class, Member) \ + Member(class, Pointer, ExecutionContext *, scope) + +DECLARE_HEAP_OBJECT(DefaultClassConstructorFunction, FunctionObject) { + DECLARE_MARKOBJECTS(DefaultClassConstructorFunction) + bool isDerivedConstructor; + + void init(QV4::ExecutionContext *scope); }; #define BoundFunctionMembers(class, Member) \ @@ -126,66 +147,72 @@ struct DefaultClassConstructorFunction : FunctionObject Member(class, HeapValue, HeapValue, boundThis) \ Member(class, Pointer, MemberData *, boundArgs) -DECLARE_HEAP_OBJECT(BoundFunction, FunctionObject) { +DECLARE_HEAP_OBJECT(BoundFunction, JavaScriptFunctionObject) { DECLARE_MARKOBJECTS(BoundFunction) - void init(QV4::ExecutionContext *scope, QV4::FunctionObject *target, const Value &boundThis, QV4::MemberData *boundArgs); + void init(QV4::FunctionObject *target, const Value &boundThis, QV4::MemberData *boundArgs); }; +struct BoundConstructor : BoundFunction {}; + } struct Q_QML_EXPORT FunctionObject: Object { - enum { - IsFunctionObject = true - }; V4_OBJECT2(FunctionObject, Object) Q_MANAGED_TYPE(FunctionObject) V4_INTERNALCLASS(FunctionObject) V4_PROTOTYPE(functionPrototype) - V4_NEEDS_DESTROY enum { NInlineProperties = 1 }; - bool canBeTailCalled() const { return d()->canBeTailCalled; } - Heap::ExecutionContext *scope() const { return d()->scope; } - Function *function() const { return d()->function; } + bool canBeTailCalled() const { return vtable()->isTailCallable; } ReturnedValue name() const; - unsigned int formalParameterCount() const { return d()->formalParameterCount(); } - unsigned int varCount() const { return d()->varCount(); } void setName(String *name) { defineReadonlyConfigurableProperty(engine()->id_name(), *name); } void createDefaultPrototypeProperty(uint protoConstructorSlot); - inline ReturnedValue callAsConstructor(const JSCallData &data) const; - ReturnedValue callAsConstructor(const Value *argv, int argc, const Value *newTarget = nullptr) const { - if (!d()->jsConstruct) - return engine()->throwTypeError(QStringLiteral("Function is not a constructor.")); - return d()->jsConstruct(this, argv, argc, newTarget ? newTarget : this); + ReturnedValue callAsConstructor( + const Value *argv, int argc, const Value *newTarget = nullptr) const + { + if (const auto callAsConstructor = vtable()->callAsConstructor) + return callAsConstructor(this, argv, argc, newTarget ? newTarget : this); + return failCallAsConstructor(); } - inline ReturnedValue call(const JSCallData &data) const; - ReturnedValue call(const Value *thisObject, const Value *argv, int argc) const { - if (!d()->jsCall) - return engine()->throwTypeError(QStringLiteral("Function can only be called with |new|.")); - return d()->jsCall(this, thisObject, argv, argc); + + ReturnedValue call(const Value *thisObject, const Value *argv, int argc) const + { + if (const auto call = vtable()->call) + return call(this, thisObject, argv, argc); + return failCall(); } - static ReturnedValue virtualCall(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc); - void call(QObject *thisObject, void **a, const QMetaType *types, int argc); - static void virtualCallWithMetaTypes(const FunctionObject *f, QObject *thisObject, - void **a, const QMetaType *types, int argc); + + void call(QObject *thisObject, void **argv, const QMetaType *types, int argc) const + { + if (const auto callWithMetaTypes = vtable()->callWithMetaTypes) + callWithMetaTypes(this, thisObject, argv, types, argc); + else + failCall(); + } + + inline ReturnedValue callAsConstructor(const JSCallData &data) const; + inline ReturnedValue call(const JSCallData &data) const; + + ReturnedValue failCall() const; + ReturnedValue failCallAsConstructor() const; + static void virtualConvertAndCall( + const FunctionObject *f, QObject *thisObject, + void **argv, const QMetaType *types, int argc); static Heap::FunctionObject *createScriptFunction(ExecutionContext *scope, Function *function); static Heap::FunctionObject *createConstructorFunction(ExecutionContext *scope, Function *function, Object *homeObject, bool isDerivedConstructor); static Heap::FunctionObject *createMemberFunction(ExecutionContext *scope, Function *function, Object *homeObject, String *name); static Heap::FunctionObject *createBuiltinFunction(ExecutionEngine *engine, StringOrSymbol *nameOrSymbol, VTable::Call code, int argumentCount); - bool strictMode() const { return d()->function ? d()->function->isStrict() : false; } bool isBinding() const; bool isBoundFunction() const; - bool isConstructor() const { - return d()->isConstructor(); - } + bool isConstructor() const { return vtable()->callAsConstructor; } ReturnedValue getHomeObject() const; @@ -195,15 +222,40 @@ struct Q_QML_EXPORT FunctionObject: Object { bool hasHasInstanceProperty() const { return !internalClass()->propertyData.at(Heap::FunctionObject::Index_HasInstance).isEmpty(); } - - QQmlSourceLocation sourceLocation() const; }; template<> inline const FunctionObject *Value::as() const { - return isManaged() && m()->internalClass->vtable->isFunctionObject ? reinterpret_cast<const FunctionObject *>(this) : nullptr; + if (!isManaged()) + return nullptr; + + const VTable *vtable = m()->internalClass->vtable; + return (vtable->call || vtable->callAsConstructor) + ? reinterpret_cast<const FunctionObject *>(this) + : nullptr; } +struct Q_QML_EXPORT JavaScriptFunctionObject: FunctionObject +{ + V4_OBJECT2(JavaScriptFunctionObject, FunctionObject) + V4_NEEDS_DESTROY + + Heap::ExecutionContext *scope() const { return d()->scope; } + + Function *function() const { return d()->function; } + unsigned int formalParameterCount() const { return d()->formalParameterCount(); } + unsigned int varCount() const { return d()->varCount(); } + bool strictMode() const { return d()->function ? d()->function->isStrict() : false; } + QQmlSourceLocation sourceLocation() const; +}; + +struct Q_QML_EXPORT DynamicFunctionObject: FunctionObject +{ + V4_OBJECT2(DynamicFunctionObject, FunctionObject) + + static ReturnedValue virtualCall( + const FunctionObject *f, const Value *thisObject, const Value *argv, int argc); +}; struct FunctionCtor: FunctionObject { @@ -225,6 +277,9 @@ struct FunctionPrototype: FunctionObject void init(ExecutionEngine *engine, Object *ctor); + static ReturnedValue virtualCall( + const FunctionObject *f, const Value *thisObject, const Value *argv, int argc); + static ReturnedValue method_toString(const FunctionObject *, const Value *thisObject, const Value *argv, int argc); static ReturnedValue method_apply(const FunctionObject *, const Value *thisObject, const Value *argv, int argc); static ReturnedValue method_call(const FunctionObject *, const Value *thisObject, const Value *argv, int argc); @@ -232,23 +287,26 @@ struct FunctionPrototype: FunctionObject static ReturnedValue method_hasInstance(const FunctionObject *, const Value *thisObject, const Value *argv, int argc); }; -struct Q_QML_EXPORT IndexedBuiltinFunction : FunctionObject +struct Q_QML_EXPORT IndexedBuiltinFunction : DynamicFunctionObject { - V4_OBJECT2(IndexedBuiltinFunction, FunctionObject) + V4_OBJECT2(IndexedBuiltinFunction, DynamicFunctionObject) }; void Heap::IndexedBuiltinFunction::init( - QV4::ExecutionContext *scope, qsizetype index, VTable::Call call) + QV4::ExecutionEngine *engine, qsizetype index, VTable::Call call) { - Heap::FunctionObject::init(scope); + Heap::FunctionObject::init(engine); this->jsCall = call; this->index = index; } -struct ArrowFunction : FunctionObject { - V4_OBJECT2(ArrowFunction, FunctionObject) +struct ArrowFunction : JavaScriptFunctionObject { + V4_OBJECT2(ArrowFunction, JavaScriptFunctionObject) V4_INTERNALCLASS(ArrowFunction) - enum { NInlineProperties = 3 }; + enum { + NInlineProperties = 3, + IsTailCallable = true, + }; static void virtualCallWithMetaTypes(const FunctionObject *f, QObject *thisObject, void **a, const QMetaType *types, int argc); @@ -279,29 +337,33 @@ struct ConstructorFunction : ScriptFunction { struct DefaultClassConstructorFunction : FunctionObject { V4_OBJECT2(DefaultClassConstructorFunction, FunctionObject) + + Heap::ExecutionContext *scope() const { return d()->scope; } static ReturnedValue virtualCallAsConstructor(const FunctionObject *, const Value *argv, int argc, const Value *); static ReturnedValue virtualCall(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc); }; -struct BoundFunction: FunctionObject { - V4_OBJECT2(BoundFunction, FunctionObject) - - static Heap::BoundFunction *create(ExecutionContext *scope, FunctionObject *target, const Value &boundThis, QV4::MemberData *boundArgs) - { - return scope->engine()->memoryManager->allocate<BoundFunction>(scope, target, boundThis, boundArgs); - } +struct BoundFunction: JavaScriptFunctionObject { + V4_OBJECT2(BoundFunction, JavaScriptFunctionObject) Heap::FunctionObject *target() const { return d()->target; } Value boundThis() const { return d()->boundThis; } Heap::MemberData *boundArgs() const { return d()->boundArgs; } - static ReturnedValue virtualCallAsConstructor(const FunctionObject *, const Value *argv, int argc, const Value *); static ReturnedValue virtualCall(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc); }; +struct BoundConstructor: BoundFunction { + V4_OBJECT2(BoundConstructor, BoundFunction) + + static ReturnedValue virtualCallAsConstructor( + const FunctionObject *f, const Value *argv, int argc, const Value *); +}; + inline bool FunctionObject::isBoundFunction() const { - return d()->vtable() == BoundFunction::staticVTable(); + const VTable *vtable = d()->vtable(); + return vtable == BoundFunction::staticVTable() || vtable == BoundConstructor::staticVTable(); } inline ReturnedValue checkedResult(QV4::ExecutionEngine *v4, ReturnedValue result) diff --git a/src/qml/jsruntime/qv4generatorobject.cpp b/src/qml/jsruntime/qv4generatorobject.cpp index e7a63ba185..f2d7dffde5 100644 --- a/src/qml/jsruntime/qv4generatorobject.cpp +++ b/src/qml/jsruntime/qv4generatorobject.cpp @@ -13,9 +13,9 @@ DEFINE_OBJECT_VTABLE(GeneratorFunctionCtor); DEFINE_OBJECT_VTABLE(GeneratorFunction); DEFINE_OBJECT_VTABLE(GeneratorObject); -void Heap::GeneratorFunctionCtor::init(QV4::ExecutionContext *scope) +void Heap::GeneratorFunctionCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("GeneratorFunction")); + Heap::FunctionObject::init(engine, QStringLiteral("GeneratorFunction")); } ReturnedValue GeneratorFunctionCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) diff --git a/src/qml/jsruntime/qv4generatorobject_p.h b/src/qml/jsruntime/qv4generatorobject_p.h index 55ccc133aa..cb2c1962c5 100644 --- a/src/qml/jsruntime/qv4generatorobject_p.h +++ b/src/qml/jsruntime/qv4generatorobject_p.h @@ -33,7 +33,7 @@ enum class GeneratorState { namespace Heap { struct GeneratorFunctionCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct GeneratorFunction : ArrowFunction { diff --git a/src/qml/jsruntime/qv4global_p.h b/src/qml/jsruntime/qv4global_p.h index d15fb356c4..e3fc0ac1b3 100644 --- a/src/qml/jsruntime/qv4global_p.h +++ b/src/qml/jsruntime/qv4global_p.h @@ -80,6 +80,7 @@ namespace Heap { struct ArrayObject; struct DateObject; struct FunctionObject; + struct JavaScriptFunctionObject; struct ErrorObject; struct ArgumentsObject; struct QObjectWrapper; diff --git a/src/qml/jsruntime/qv4globalobject.cpp b/src/qml/jsruntime/qv4globalobject.cpp index 37548ffc9f..989de0de23 100644 --- a/src/qml/jsruntime/qv4globalobject.cpp +++ b/src/qml/jsruntime/qv4globalobject.cpp @@ -290,10 +290,10 @@ static QString decode(const QString &input, DecodeMode decodeMode, bool *ok) DEFINE_OBJECT_VTABLE(EvalFunction); -void Heap::EvalFunction::init(QV4::ExecutionContext *scope) +void Heap::EvalFunction::init(QV4::ExecutionEngine *engine) { - Scope s(scope); - Heap::FunctionObject::init(scope, s.engine->id_eval()); + Scope s(engine); + Heap::FunctionObject::init(engine, s.engine->id_eval()); ScopedFunctionObject f(s, this); f->defineReadonlyConfigurableProperty(s.engine->id_length(), Value::fromInt32(1)); } diff --git a/src/qml/jsruntime/qv4globalobject_p.h b/src/qml/jsruntime/qv4globalobject_p.h index 71e06ef417..fd23d71332 100644 --- a/src/qml/jsruntime/qv4globalobject_p.h +++ b/src/qml/jsruntime/qv4globalobject_p.h @@ -24,7 +24,7 @@ namespace QV4 { namespace Heap { struct EvalFunction : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; } diff --git a/src/qml/jsruntime/qv4managed_p.h b/src/qml/jsruntime/qv4managed_p.h index c5f5fbff8e..aeac8c4914 100644 --- a/src/qml/jsruntime/qv4managed_p.h +++ b/src/qml/jsruntime/qv4managed_p.h @@ -77,7 +77,7 @@ struct Q_QML_EXPORT Managed : Value, VTableBase IsString = false, IsStringOrSymbol = false, IsObject = false, - IsFunctionObject = false, + IsTailCallable = false, IsErrorObject = false, IsArrayData = false }; diff --git a/src/qml/jsruntime/qv4mapobject.cpp b/src/qml/jsruntime/qv4mapobject.cpp index 4bb9617b93..b927efd685 100644 --- a/src/qml/jsruntime/qv4mapobject.cpp +++ b/src/qml/jsruntime/qv4mapobject.cpp @@ -12,14 +12,14 @@ DEFINE_OBJECT_VTABLE(WeakMapCtor); DEFINE_OBJECT_VTABLE(MapCtor); DEFINE_OBJECT_VTABLE(MapObject); -void Heap::WeakMapCtor::init(QV4::ExecutionContext *scope) +void Heap::WeakMapCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("WeakMap")); + Heap::FunctionObject::init(engine, QStringLiteral("WeakMap")); } -void Heap::MapCtor::init(QV4::ExecutionContext *scope) +void Heap::MapCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Map")); + Heap::FunctionObject::init(engine, QStringLiteral("Map")); } ReturnedValue WeakMapCtor::construct(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget, bool weakMap) diff --git a/src/qml/jsruntime/qv4mapobject_p.h b/src/qml/jsruntime/qv4mapobject_p.h index 68bc7ceed8..b5eeb68b0c 100644 --- a/src/qml/jsruntime/qv4mapobject_p.h +++ b/src/qml/jsruntime/qv4mapobject_p.h @@ -27,11 +27,11 @@ class ESTable; namespace Heap { struct WeakMapCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct MapCtor : WeakMapCtor { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct MapObject : Object { diff --git a/src/qml/jsruntime/qv4numberobject.cpp b/src/qml/jsruntime/qv4numberobject.cpp index d744e569f5..5299a2568a 100644 --- a/src/qml/jsruntime/qv4numberobject.cpp +++ b/src/qml/jsruntime/qv4numberobject.cpp @@ -36,9 +36,9 @@ const NumberLocale *NumberLocale::instance() return numberLocaleHolder(); } -void Heap::NumberCtor::init(QV4::ExecutionContext *scope) +void Heap::NumberCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Number")); + Heap::FunctionObject::init(engine, QStringLiteral("Number")); } ReturnedValue NumberCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) diff --git a/src/qml/jsruntime/qv4numberobject_p.h b/src/qml/jsruntime/qv4numberobject_p.h index 8ac2bd1f79..3f0d6d9425 100644 --- a/src/qml/jsruntime/qv4numberobject_p.h +++ b/src/qml/jsruntime/qv4numberobject_p.h @@ -25,7 +25,7 @@ namespace QV4 { namespace Heap { struct NumberCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; } diff --git a/src/qml/jsruntime/qv4objectproto.cpp b/src/qml/jsruntime/qv4objectproto.cpp index e7f96a12ba..2a78bb4540 100644 --- a/src/qml/jsruntime/qv4objectproto.cpp +++ b/src/qml/jsruntime/qv4objectproto.cpp @@ -19,9 +19,9 @@ using namespace QV4; DEFINE_OBJECT_VTABLE(ObjectCtor); -void Heap::ObjectCtor::init(QV4::ExecutionContext *scope) +void Heap::ObjectCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Object")); + Heap::FunctionObject::init(engine, QStringLiteral("Object")); } ReturnedValue ObjectCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) diff --git a/src/qml/jsruntime/qv4objectproto_p.h b/src/qml/jsruntime/qv4objectproto_p.h index d152bfd175..d74cd64926 100644 --- a/src/qml/jsruntime/qv4objectproto_p.h +++ b/src/qml/jsruntime/qv4objectproto_p.h @@ -25,7 +25,7 @@ namespace QV4 { namespace Heap { struct ObjectCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; } diff --git a/src/qml/jsruntime/qv4promiseobject.cpp b/src/qml/jsruntime/qv4promiseobject.cpp index 16cffea124..b8ede3e578 100644 --- a/src/qml/jsruntime/qv4promiseobject.cpp +++ b/src/qml/jsruntime/qv4promiseobject.cpp @@ -314,9 +314,9 @@ void Heap::PromiseReaction::triggerWithValue(ExecutionEngine *e, const Value *va handler->addReaction(e, reaction, value); } -void Heap::PromiseCtor::init(QV4::ExecutionContext *scope) +void Heap::PromiseCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Promise")); + Heap::FunctionObject::init(engine, QStringLiteral("Promise")); } void Heap::PromiseObject::init(ExecutionEngine *e) diff --git a/src/qml/jsruntime/qv4promiseobject_p.h b/src/qml/jsruntime/qv4promiseobject_p.h index ca31f00881..fbde9f95e0 100644 --- a/src/qml/jsruntime/qv4promiseobject_p.h +++ b/src/qml/jsruntime/qv4promiseobject_p.h @@ -50,7 +50,7 @@ protected: namespace Heap { struct PromiseCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; #define PromiseObjectMembers(class, Member) \ diff --git a/src/qml/jsruntime/qv4proxy.cpp b/src/qml/jsruntime/qv4proxy.cpp index 109ab61059..974788d420 100644 --- a/src/qml/jsruntime/qv4proxy.cpp +++ b/src/qml/jsruntime/qv4proxy.cpp @@ -13,6 +13,7 @@ using namespace QV4; DEFINE_OBJECT_VTABLE(ProxyObject); DEFINE_OBJECT_VTABLE(ProxyFunctionObject); +DEFINE_OBJECT_VTABLE(ProxyConstructorObject); void Heap::ProxyObject::init(const QV4::Object *target, const QV4::Object *handler) { @@ -25,12 +26,9 @@ void Heap::ProxyObject::init(const QV4::Object *target, const QV4::Object *handl void Heap::ProxyFunctionObject::init(const QV4::FunctionObject *target, const QV4::Object *handler) { ExecutionEngine *e = internalClass->engine; - FunctionObject::init(e->rootContext()); + FunctionObject::init(e); this->target.set(e, target->d()); this->handler.set(e, handler->d()); - - if (!target->isConstructor()) - jsConstruct = nullptr; } @@ -643,7 +641,8 @@ OwnPropertyKeyIterator *ProxyObject::virtualOwnPropertyKeys(const Object *m, Val } -ReturnedValue ProxyFunctionObject::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) +ReturnedValue ProxyConstructorObject::virtualCallAsConstructor( + const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) { Scope scope(f); const ProxyObject *o = static_cast<const ProxyObject *>(f); @@ -658,10 +657,8 @@ ReturnedValue ProxyFunctionObject::virtualCallAsConstructor(const FunctionObject if (scope.hasException()) return Encode::undefined(); - if (trap->isNullOrUndefined()) { - Q_ASSERT(target->isConstructor()); + if (trap->isNullOrUndefined()) return target->callAsConstructor(argv, argc, newTarget); - } if (!trap->isFunctionObject()) return scope.engine->throwTypeError(); @@ -708,11 +705,11 @@ ReturnedValue ProxyFunctionObject::virtualCall(const FunctionObject *f, const Va DEFINE_OBJECT_VTABLE(Proxy); -void Heap::Proxy::init(QV4::ExecutionContext *ctx) +void Heap::Proxy::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(ctx, QStringLiteral("Proxy")); + Heap::FunctionObject::init(engine, QStringLiteral("Proxy")); - Scope scope(ctx); + Scope scope(engine); Scoped<QV4::Proxy> ctor(scope, this); ctor->defineDefaultProperty(QStringLiteral("revocable"), QV4::Proxy::method_revocable, 2); ctor->defineReadonlyConfigurableProperty(scope.engine->id_length(), Value::fromInt32(2)); @@ -734,9 +731,18 @@ ReturnedValue Proxy::virtualCallAsConstructor(const FunctionObject *f, const Val return scope.engine->throwTypeError(); const FunctionObject *targetFunction = target->as<FunctionObject>(); - if (targetFunction) - return scope.engine->memoryManager->allocate<ProxyFunctionObject>(targetFunction, handler)->asReturnedValue(); - return scope.engine->memoryManager->allocate<ProxyObject>(target, handler)->asReturnedValue(); + if (!targetFunction) { + return scope.engine->memoryManager->allocate<ProxyObject>(target, handler) + ->asReturnedValue(); + } + + if (targetFunction->isConstructor()) { + return scope.engine->memoryManager->allocate<ProxyConstructorObject>( + targetFunction, handler)->asReturnedValue(); + } + + return scope.engine->memoryManager->allocate<ProxyFunctionObject>(targetFunction, handler) + ->asReturnedValue(); } ReturnedValue Proxy::virtualCall(const FunctionObject *f, const Value *, const Value *, int) @@ -753,7 +759,10 @@ ReturnedValue Proxy::method_revocable(const FunctionObject *f, const Value *, co Q_ASSERT(proxy); ScopedString revoke(scope, scope.engine->newString(QStringLiteral("revoke"))); - ScopedFunctionObject revoker(scope, scope.engine->memoryManager->allocate<FunctionObject>(scope.engine->rootContext(), nullptr, method_revoke)); + ScopedFunctionObject revoker( + scope, + scope.engine->memoryManager->allocate<DynamicFunctionObject>( + scope.engine, nullptr, method_revoke)); revoker->defineReadonlyConfigurableProperty(scope.engine->id_length(), Value::fromInt32(0)); revoker->defineDefaultProperty(scope.engine->symbol_revokableProxy(), proxy); diff --git a/src/qml/jsruntime/qv4proxy_p.h b/src/qml/jsruntime/qv4proxy_p.h index b3be05a11b..b3ce9c7a96 100644 --- a/src/qml/jsruntime/qv4proxy_p.h +++ b/src/qml/jsruntime/qv4proxy_p.h @@ -37,13 +37,15 @@ struct ProxyFunctionObject : ProxyObject { void init(const QV4::FunctionObject *target, const QV4::Object *handler); }; +struct ProxyConstructorObject : ProxyFunctionObject {}; + #define ProxyMembers(class, Member) \ Member(class, Pointer, Symbol *, revokableProxySymbol) \ DECLARE_HEAP_OBJECT(Proxy, FunctionObject) { DECLARE_MARKOBJECTS(Proxy) - void init(QV4::ExecutionContext *ctx); + void init(ExecutionEngine *engine); }; } @@ -60,9 +62,6 @@ struct ProxyObject : FunctionObject { V4_OBJECT2(ProxyObject, Object) Q_MANAGED_TYPE(ProxyObject) V4_INTERNALCLASS(ProxyObject) - enum { - IsFunctionObject = false - }; static ReturnedValue virtualGet(const Managed *m, PropertyKey id, const Value *receiver, bool *hasProperty); static bool virtualPut(Managed *m, PropertyKey id, const Value &value, Value *receiver); @@ -81,14 +80,16 @@ struct ProxyFunctionObject : ProxyObject { V4_OBJECT2(ProxyFunctionObject, FunctionObject) Q_MANAGED_TYPE(ProxyObject) V4_INTERNALCLASS(ProxyFunctionObject) - enum { - IsFunctionObject = true - }; - static ReturnedValue virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *); static ReturnedValue virtualCall(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc); }; +struct ProxyConstructorObject : ProxyFunctionObject { + V4_OBJECT2(ProxyConstructorObject, ProxyFunctionObject) + + static ReturnedValue virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *); +}; + struct Proxy : FunctionObject { V4_OBJECT2(Proxy, FunctionObject) diff --git a/src/qml/jsruntime/qv4qmetaobjectwrapper.cpp b/src/qml/jsruntime/qv4qmetaobjectwrapper.cpp new file mode 100644 index 0000000000..13d93c7122 --- /dev/null +++ b/src/qml/jsruntime/qv4qmetaobjectwrapper.cpp @@ -0,0 +1,126 @@ +// Copyright (C) 2024 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "qv4qmetaobjectwrapper_p.h" + +#include <private/qqmlobjectorgadget_p.h> +#include <private/qv4jscall_p.h> +#include <private/qv4qobjectwrapper_p.h> + +QT_BEGIN_NAMESPACE + +using namespace Qt::StringLiterals; + +namespace QV4 { + +void Heap::QMetaObjectWrapper::init(const QMetaObject *metaObject) +{ + FunctionObject::init(); + this->metaObject = metaObject; + constructors = nullptr; + constructorCount = 0; +} + +void Heap::QMetaObjectWrapper::destroy() +{ + delete[] constructors; +} + +void Heap::QMetaObjectWrapper::ensureConstructorsCache() { + + const int count = metaObject->constructorCount(); + if (constructorCount != count) { + delete[] constructors; + constructorCount = count; + if (count == 0) { + constructors = nullptr; + return; + } + constructors = new QQmlPropertyData[count]; + + for (int i = 0; i < count; ++i) { + QMetaMethod method = metaObject->constructor(i); + QQmlPropertyData &d = constructors[i]; + d.load(method); + d.setCoreIndex(i); + } + } +} + + +ReturnedValue QMetaObjectWrapper::create(ExecutionEngine *engine, const QMetaObject* metaObject) { + + Scope scope(engine); + Scoped<QMetaObjectWrapper> mo(scope, engine->memoryManager->allocate<QMetaObjectWrapper>(metaObject)->asReturnedValue()); + mo->init(engine); + return mo->asReturnedValue(); +} + +void QMetaObjectWrapper::init(ExecutionEngine *) { + const QMetaObject & mo = *d()->metaObject; + + for (int i = 0; i < mo.enumeratorCount(); i++) { + QMetaEnum Enum = mo.enumerator(i); + for (int k = 0; k < Enum.keyCount(); k++) { + const char* key = Enum.key(k); + const int value = Enum.value(k); + defineReadonlyProperty(QLatin1String(key), Value::fromInt32(value)); + } + } +} + +ReturnedValue QMetaObjectWrapper::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *) +{ + const QMetaObjectWrapper *This = static_cast<const QMetaObjectWrapper*>(f); + return This->constructInternal(argv, argc); +} + +ReturnedValue QMetaObjectWrapper::constructInternal(const Value *argv, int argc) const +{ + + d()->ensureConstructorsCache(); + + ExecutionEngine *v4 = engine(); + const QMetaObject* mo = d()->metaObject; + if (d()->constructorCount == 0) { + return v4->throwTypeError(QLatin1String(mo->className()) + + QLatin1String(" has no invokable constructor")); + } + + Scope scope(v4); + Scoped<QObjectWrapper> object(scope); + JSCallData cData(nullptr, argv, argc); + CallData *callData = cData.callData(scope); + + const QQmlObjectOrGadget objectOrGadget(mo); + + if (d()->constructorCount == 1) { + object = QObjectMethod::callPrecise( + objectOrGadget, d()->constructors[0], v4, callData, QMetaObject::CreateInstance); + } else if (const QQmlPropertyData *ctor = QObjectMethod::resolveOverloaded( + objectOrGadget, d()->constructors, d()->constructorCount, v4, callData)) { + object = QObjectMethod::callPrecise( + objectOrGadget, *ctor, v4, callData, QMetaObject::CreateInstance); + } + if (object) { + Scoped<QMetaObjectWrapper> metaObject(scope, this); + object->defineDefaultProperty(v4->id_constructor(), metaObject); + object->setPrototypeOf(const_cast<QMetaObjectWrapper*>(this)); + } + + return object.asReturnedValue(); +} + +bool QMetaObjectWrapper::virtualIsEqualTo(Managed *a, Managed *b) +{ + const QMetaObjectWrapper *aMetaObject = a->as<QMetaObjectWrapper>(); + Q_ASSERT(aMetaObject); + const QMetaObjectWrapper *bMetaObject = b->as<QMetaObjectWrapper>(); + return bMetaObject && aMetaObject->metaObject() == bMetaObject->metaObject(); +} + +DEFINE_OBJECT_VTABLE(QMetaObjectWrapper); + +} // namespace QV4 + +QT_END_NAMESPACE diff --git a/src/qml/jsruntime/qv4qmetaobjectwrapper_p.h b/src/qml/jsruntime/qv4qmetaobjectwrapper_p.h new file mode 100644 index 0000000000..063bc089e7 --- /dev/null +++ b/src/qml/jsruntime/qv4qmetaobjectwrapper_p.h @@ -0,0 +1,66 @@ +// Copyright (C) 2024 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef QV4QMETAOBJECTWRAPPER_P_H +#define QV4QMETAOBJECTWRAPPER_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <private/qv4functionobject_p.h> +#include <private/qv4value_p.h> + +#include <QtCore/qmetaobject.h> + +QT_BEGIN_NAMESPACE + +class QQmlPropertyData; + +namespace QV4 { +namespace Heap { + +struct QMetaObjectWrapper : FunctionObject { + const QMetaObject* metaObject; + QQmlPropertyData *constructors; + int constructorCount; + + void init(const QMetaObject* metaObject); + void destroy(); + void ensureConstructorsCache(); +}; + +} // namespace Heap + +struct Q_QML_EXPORT QMetaObjectWrapper : public FunctionObject +{ + V4_OBJECT2(QMetaObjectWrapper, FunctionObject) + V4_NEEDS_DESTROY + + static ReturnedValue create(ExecutionEngine *engine, const QMetaObject* metaObject); + const QMetaObject *metaObject() const { return d()->metaObject; } + +protected: + static ReturnedValue virtualCallAsConstructor( + const FunctionObject *, const Value *argv, int argc, const Value *); + static bool virtualIsEqualTo(Managed *a, Managed *b); + +private: + void init(ExecutionEngine *engine); + ReturnedValue constructInternal(const Value *argv, int argc) const; +}; + +} // namespace QV4 + +QT_END_NAMESPACE + +#endif // QV4QMETAOBJECTWRAPPER_P_H + + diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp index 2cbb152dd0..2edeb54b11 100644 --- a/src/qml/jsruntime/qv4qobjectwrapper.cpp +++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp @@ -360,20 +360,15 @@ ReturnedValue QObjectWrapper::getProperty( Q_ASSERT(vmemo); return vmemo->vmeMethod(property->coreIndex()); } else if (property->isV4Function()) { - Scope scope(engine); - ScopedContext global(scope, engine->qmlContext()); - if (!global) - global = engine->rootContext(); return QObjectMethod::create( - global, (flags & AttachMethods) ? wrapper : nullptr, property->coreIndex()); + engine, (flags & AttachMethods) ? wrapper : nullptr, property->coreIndex()); } else if (property->isSignalHandler()) { QmlSignalHandler::initProto(engine); return engine->memoryManager->allocate<QmlSignalHandler>( object, property->coreIndex())->asReturnedValue(); } else { - ExecutionContext *global = engine->rootContext(); return QObjectMethod::create( - global, (flags & AttachMethods) ? wrapper : nullptr, property->coreIndex()); + engine, (flags & AttachMethods) ? wrapper : nullptr, property->coreIndex()); } } @@ -405,8 +400,7 @@ static OptionalReturnedValue getDestroyOrToStringMethod( if (hasProperty) *hasProperty = true; - ExecutionContext *global = v4->rootContext(); - return OptionalReturnedValue(QObjectMethod::create(global, qobj, index)); + return OptionalReturnedValue(QObjectMethod::create(v4, qobj, index)); } static OptionalReturnedValue getPropertyFromImports( @@ -641,7 +635,7 @@ void QObjectWrapper::setProperty( QQmlRefPointer<QQmlContextData> callingQmlContext = scope.engine->callingQmlContext(); Scoped<QQmlBindingFunction> bindingFunction(scope, (const Value &)f); - ScopedFunctionObject f(scope, bindingFunction->bindingFunction()); + Scoped<JavaScriptFunctionObject> f(scope, bindingFunction->bindingFunction()); ScopedContext ctx(scope, f->scope()); // binding assignment. @@ -1924,9 +1918,9 @@ static bool requiresStrictArguments(const QQmlObjectOrGadget &object) && metaObject->classInfo(indexOfClassInfo).value() == QByteArrayView("true"); } -static ReturnedValue CallPrecise(const QQmlObjectOrGadget &object, const QQmlPropertyData &data, - ExecutionEngine *engine, CallData *callArgs, - QMetaObject::Call callType = QMetaObject::InvokeMetaMethod) +ReturnedValue QObjectMethod::callPrecise( + const QQmlObjectOrGadget &object, const QQmlPropertyData &data, ExecutionEngine *engine, + CallData *callArgs, QMetaObject::Call callType) { QByteArray unknownTypeError; @@ -2011,7 +2005,7 @@ Resolve the overloaded method to call. The algorithm works conceptually like th If two or more overloads have the same match score, return the last one. The match score is constructed by adding the matchScore() result for each of the parameters. */ -static const QQmlPropertyData *ResolveOverloaded( +const QQmlPropertyData *QObjectMethod::resolveOverloaded( const QQmlObjectOrGadget &object, const QQmlPropertyData *methods, int methodCount, ExecutionEngine *engine, CallData *callArgs) { @@ -2165,7 +2159,7 @@ static bool ExactMatch(QMetaType passed, QMetaType required, const void *data) return false; } -static const QQmlPropertyData *ResolveOverloaded( +const QQmlPropertyData *QObjectMethod::resolveOverloaded( const QQmlPropertyData *methods, int methodCount, void **argv, int argc, const QMetaType *types) { @@ -2559,21 +2553,22 @@ ReturnedValue CallArgument::toValue(ExecutionEngine *engine) return Encode::undefined(); } -ReturnedValue QObjectMethod::create(ExecutionContext *scope, Heap::Object *wrapper, int index) +ReturnedValue QObjectMethod::create(ExecutionEngine *engine, Heap::Object *wrapper, int index) { - Scope valueScope(scope); + Scope valueScope(engine); Scoped<QObjectMethod> method( valueScope, - valueScope.engine->memoryManager->allocate<QObjectMethod>(scope, wrapper, index)); + engine->memoryManager->allocate<QObjectMethod>(engine, wrapper, index)); return method.asReturnedValue(); } -ReturnedValue QObjectMethod::create(ExecutionContext *scope, Heap::QQmlValueTypeWrapper *valueType, int index) +ReturnedValue QObjectMethod::create( + ExecutionEngine *engine, Heap::QQmlValueTypeWrapper *valueType, int index) { - Scope valueScope(scope); + Scope valueScope(engine); Scoped<QObjectMethod> method( valueScope, - valueScope.engine->memoryManager->allocate<QObjectMethod>(scope, valueType, index)); + engine->memoryManager->allocate<QObjectMethod>(engine, valueType, index)); return method.asReturnedValue(); } @@ -2596,11 +2591,10 @@ ReturnedValue QObjectMethod::create( } } - Scoped<ExecutionContext> context(valueScope, cloneFrom->scope.get()); Scoped<QObjectMethod> method( valueScope, engine->memoryManager->allocate<QV4::QObjectMethod>( - context, valueTypeWrapper ? valueTypeWrapper->d() : object, cloneFrom->index)); + engine, valueTypeWrapper ? valueTypeWrapper->d() : object, cloneFrom->index)); method->d()->methodCount = cloneFrom->methodCount; @@ -2626,10 +2620,10 @@ ReturnedValue QObjectMethod::create( return method.asReturnedValue(); } -void Heap::QObjectMethod::init(QV4::ExecutionContext *scope, Object *object, int methodIndex) +void Heap::QObjectMethod::init(QV4::ExecutionEngine *engine, Object *object, int methodIndex) { - Heap::FunctionObject::init(scope); - wrapper.set(internalClass->engine, object); + Heap::FunctionObject::init(engine); + wrapper.set(engine, object); index = methodIndex; } @@ -2944,7 +2938,7 @@ ReturnedValue QObjectMethod::callInternal(const Value *thisObject, const Value * if (d()->methodCount != 1) { Q_ASSERT(d()->methodCount > 0); - method = ResolveOverloaded(object, d()->methods, d()->methodCount, v4, callData); + method = resolveOverloaded(object, d()->methods, d()->methodCount, v4, callData); if (method == nullptr) return Encode::undefined(); } @@ -2962,7 +2956,7 @@ ReturnedValue QObjectMethod::callInternal(const Value *thisObject, const Value * }); } - return doCall([&]() { return CallPrecise(object, *method, v4, callData); }); + return doCall([&]() { return callPrecise(object, *method, v4, callData); }); } struct ToStringMetaMethod @@ -3032,7 +3026,7 @@ void QObjectMethod::callInternalWithMetaTypes( const QQmlPropertyData *method = d()->methods; if (d()->methodCount != 1) { Q_ASSERT(d()->methodCount > 0); - method = ResolveOverloaded(d()->methods, d()->methodCount, argv, argc, types); + method = resolveOverloaded(d()->methods, d()->methodCount, argv, argc, types); } if (!method || method->isV4Function()) { @@ -3084,114 +3078,6 @@ void QObjectMethod::callInternalWithMetaTypes( DEFINE_OBJECT_VTABLE(QObjectMethod); - -void Heap::QMetaObjectWrapper::init(const QMetaObject *metaObject) -{ - FunctionObject::init(); - this->metaObject = metaObject; - constructors = nullptr; - constructorCount = 0; -} - -void Heap::QMetaObjectWrapper::destroy() -{ - delete[] constructors; -} - -void Heap::QMetaObjectWrapper::ensureConstructorsCache() { - - const int count = metaObject->constructorCount(); - if (constructorCount != count) { - delete[] constructors; - constructorCount = count; - if (count == 0) { - constructors = nullptr; - return; - } - constructors = new QQmlPropertyData[count]; - - for (int i = 0; i < count; ++i) { - QMetaMethod method = metaObject->constructor(i); - QQmlPropertyData &d = constructors[i]; - d.load(method); - d.setCoreIndex(i); - } - } -} - - -ReturnedValue QMetaObjectWrapper::create(ExecutionEngine *engine, const QMetaObject* metaObject) { - - Scope scope(engine); - Scoped<QMetaObjectWrapper> mo(scope, engine->memoryManager->allocate<QMetaObjectWrapper>(metaObject)->asReturnedValue()); - mo->init(engine); - return mo->asReturnedValue(); -} - -void QMetaObjectWrapper::init(ExecutionEngine *) { - const QMetaObject & mo = *d()->metaObject; - - for (int i = 0; i < mo.enumeratorCount(); i++) { - QMetaEnum Enum = mo.enumerator(i); - for (int k = 0; k < Enum.keyCount(); k++) { - const char* key = Enum.key(k); - const int value = Enum.value(k); - defineReadonlyProperty(QLatin1String(key), Value::fromInt32(value)); - } - } -} - -ReturnedValue QMetaObjectWrapper::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *) -{ - const QMetaObjectWrapper *This = static_cast<const QMetaObjectWrapper*>(f); - return This->constructInternal(argv, argc); -} - -ReturnedValue QMetaObjectWrapper::constructInternal(const Value *argv, int argc) const -{ - - d()->ensureConstructorsCache(); - - ExecutionEngine *v4 = engine(); - const QMetaObject* mo = d()->metaObject; - if (d()->constructorCount == 0) { - return v4->throwTypeError(QLatin1String(mo->className()) - + QLatin1String(" has no invokable constructor")); - } - - Scope scope(v4); - Scoped<QObjectWrapper> object(scope); - JSCallData cData(nullptr, argv, argc); - CallData *callData = cData.callData(scope); - - const QQmlObjectOrGadget objectOrGadget(mo); - - if (d()->constructorCount == 1) { - object = CallPrecise(objectOrGadget, d()->constructors[0], v4, callData, QMetaObject::CreateInstance); - } else if (const QQmlPropertyData *ctor = ResolveOverloaded( - objectOrGadget, d()->constructors, d()->constructorCount, v4, callData)) { - object = CallPrecise(objectOrGadget, *ctor, v4, callData, QMetaObject::CreateInstance); - } - if (object) { - Scoped<QMetaObjectWrapper> metaObject(scope, this); - object->defineDefaultProperty(v4->id_constructor(), metaObject); - object->setPrototypeOf(const_cast<QMetaObjectWrapper*>(this)); - } - return object.asReturnedValue(); - -} - -bool QMetaObjectWrapper::virtualIsEqualTo(Managed *a, Managed *b) -{ - const QMetaObjectWrapper *aMetaObject = a->as<QMetaObjectWrapper>(); - Q_ASSERT(aMetaObject); - const QMetaObjectWrapper *bMetaObject = b->as<QMetaObjectWrapper>(); - return bMetaObject && aMetaObject->metaObject() == bMetaObject->metaObject(); -} - -DEFINE_OBJECT_VTABLE(QMetaObjectWrapper); - - void Heap::QmlSignalHandler::init(QObject *object, int signalIndex) { Object::init(); @@ -3214,7 +3100,7 @@ ReturnedValue QmlSignalHandler::call(const Value *thisObject, const Value *argv, Scope scope(engine()); Scoped<QObjectMethod> method( scope, QObjectMethod::create( - scope.engine->rootContext(), + scope.engine, static_cast<Heap::QObjectWrapper *>(nullptr), signalIndex())); diff --git a/src/qml/jsruntime/qv4qobjectwrapper_p.h b/src/qml/jsruntime/qv4qobjectwrapper_p.h index 7225612f08..288585f844 100644 --- a/src/qml/jsruntime/qv4qobjectwrapper_p.h +++ b/src/qml/jsruntime/qv4qobjectwrapper_p.h @@ -33,6 +33,7 @@ class QObject; class QQmlData; class QQmlPropertyCache; class QQmlPropertyData; +class QQmlObjectOrGadget; namespace QV4 { struct QObjectSlotDispatcher; @@ -71,7 +72,7 @@ DECLARE_EXPORTED_HEAP_OBJECT(QObjectMethod, FunctionObject) { int methodCount; int index; - void init(QV4::ExecutionContext *scope, Object *wrapper, int index); + void init(QV4::ExecutionEngine *engine, Object *wrapper, int index); void destroy() { if (methods != reinterpret_cast<const QQmlPropertyData *>(&_singleMethod)) @@ -97,16 +98,6 @@ DECLARE_EXPORTED_HEAP_OBJECT(QObjectMethod, FunctionObject) { QV4::Heap::QObjectMethod::ThisObjectMode checkThisObject(const QMetaObject *thisMeta) const; }; -struct QMetaObjectWrapper : FunctionObject { - const QMetaObject* metaObject; - QQmlPropertyData *constructors; - int constructorCount; - - void init(const QMetaObject* metaObject); - void destroy(); - void ensureConstructorsCache(); -}; - struct QmlSignalHandler : Object { void init(QObject *object, int signalIndex); void destroy() { @@ -357,10 +348,11 @@ struct Q_QML_EXPORT QObjectMethod : public QV4::FunctionObject enum { DestroyMethod = -1, ToStringMethod = -2 }; - static ReturnedValue create(QV4::ExecutionContext *scope, Heap::Object *wrapper, int index); + static ReturnedValue create(ExecutionEngine *engine, Heap::Object *wrapper, int index); static ReturnedValue create( - QV4::ExecutionContext *scope, Heap::QQmlValueTypeWrapper *valueType, int index); - static ReturnedValue create(QV4::ExecutionEngine *engine, Heap::QObjectMethod *cloneFrom, + ExecutionEngine *engine, Heap::QQmlValueTypeWrapper *valueType, int index); + static ReturnedValue create( + ExecutionEngine *engine, Heap::QObjectMethod *cloneFrom, Heap::Object *wrapper, Heap::Object *object); int methodIndex() const { return d()->index; } @@ -385,24 +377,22 @@ struct Q_QML_EXPORT QObjectMethod : public QV4::FunctionObject QObject *thisObject, void **argv, const QMetaType *types, int argc) const; static QPair<QObject *, int> extractQtMethod(const QV4::FunctionObject *function); -}; - -struct Q_QML_EXPORT QMetaObjectWrapper : public QV4::FunctionObject -{ - V4_OBJECT2(QMetaObjectWrapper, QV4::FunctionObject) - V4_NEEDS_DESTROY +private: + friend struct QMetaObjectWrapper; - static ReturnedValue create(ExecutionEngine *engine, const QMetaObject* metaObject); - const QMetaObject *metaObject() const { return d()->metaObject; } + static const QQmlPropertyData *resolveOverloaded( + const QQmlObjectOrGadget &object, const QQmlPropertyData *methods, int methodCount, + ExecutionEngine *engine, CallData *callArgs); -protected: - static ReturnedValue virtualCallAsConstructor(const FunctionObject *, const Value *argv, int argc, const Value *); - static bool virtualIsEqualTo(Managed *a, Managed *b); + static const QQmlPropertyData *resolveOverloaded( + const QQmlPropertyData *methods, int methodCount, + void **argv, int argc, const QMetaType *types); -private: - void init(ExecutionEngine *engine); - ReturnedValue constructInternal(const Value *argv, int argc) const; + static ReturnedValue callPrecise( + const QQmlObjectOrGadget &object, const QQmlPropertyData &data, + ExecutionEngine *engine, CallData *callArgs, + QMetaObject::Call callType = QMetaObject::InvokeMetaMethod); }; struct Q_QML_EXPORT QmlSignalHandler : public QV4::Object diff --git a/src/qml/jsruntime/qv4regexpobject.cpp b/src/qml/jsruntime/qv4regexpobject.cpp index acb9f0acfc..144cd39bcd 100644 --- a/src/qml/jsruntime/qv4regexpobject.cpp +++ b/src/qml/jsruntime/qv4regexpobject.cpp @@ -195,9 +195,9 @@ ReturnedValue RegExpObject::builtinExec(ExecutionEngine *engine, const String *s DEFINE_OBJECT_VTABLE(RegExpCtor); -void Heap::RegExpCtor::init(QV4::ExecutionContext *scope) +void Heap::RegExpCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("RegExp")); + Heap::FunctionObject::init(engine, QStringLiteral("RegExp")); clearLastMatch(); } diff --git a/src/qml/jsruntime/qv4regexpobject_p.h b/src/qml/jsruntime/qv4regexpobject_p.h index 8d52300013..179a01fb45 100644 --- a/src/qml/jsruntime/qv4regexpobject_p.h +++ b/src/qml/jsruntime/qv4regexpobject_p.h @@ -50,7 +50,7 @@ DECLARE_HEAP_OBJECT(RegExpObject, Object) { DECLARE_HEAP_OBJECT(RegExpCtor, FunctionObject) { DECLARE_MARKOBJECTS(RegExpCtor) - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); void clearLastMatch(); }; diff --git a/src/qml/jsruntime/qv4runtime.cpp b/src/qml/jsruntime/qv4runtime.cpp index c51c94ffe4..8bfe2680f6 100644 --- a/src/qml/jsruntime/qv4runtime.cpp +++ b/src/qml/jsruntime/qv4runtime.cpp @@ -1029,7 +1029,7 @@ ReturnedValue Runtime::LoadName::call(ExecutionEngine *engine, int nameIndex) static Object *getSuperBase(Scope &scope) { - ScopedFunctionObject f(scope); + Scoped<JavaScriptFunctionObject> f(scope); ScopedObject homeObject(scope); if (scope.engine->currentStackFrame->isJSTypesFrame()) { JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>( @@ -1188,7 +1188,7 @@ ReturnedValue Runtime::LoadSuperConstructor::call(ExecutionEngine *engine, const if (!f) return engine->throwTypeError(); Heap::Object *c = static_cast<const Object &>(t).getPrototypeOf(); - if (!c->vtable()->isFunctionObject || !static_cast<Heap::FunctionObject *>(c)->isConstructor()) + if (!c->vtable()->callAsConstructor) return engine->throwTypeError(); return c->asReturnedValue(); } @@ -1627,20 +1627,23 @@ ReturnedValue Runtime::TailCall::call(JSTypesStackFrame *frame, ExecutionEngine int argc = tos[StackOffsets::tailCall_argc].int_32(); Q_ASSERT(argc >= 0); - if (!function.isFunctionObject()) + const JavaScriptFunctionObject *jsfo = function.as<JavaScriptFunctionObject>(); + if (!jsfo) { + if (const FunctionObject *fo = function.as<FunctionObject>()) + return checkedResult(engine, fo->call(&thisObject, argv, argc)); return engine->throwTypeError(); + } - const FunctionObject &fo = static_cast<const FunctionObject &>(function); - if (!frame->callerCanHandleTailCall() || !fo.canBeTailCalled() || engine->debugger() - || unsigned(argc) > fo.formalParameterCount()) { + if (!frame->callerCanHandleTailCall() || !jsfo->canBeTailCalled() || engine->debugger() + || unsigned(argc) > jsfo->formalParameterCount()) { // Cannot tailcall, do a normal call: - return checkedResult(engine, fo.call(&thisObject, argv, argc)); + return checkedResult(engine, jsfo->call(&thisObject, argv, argc)); } memmove(frame->jsFrame->args, argv, argc * sizeof(Value)); - frame->init(fo.function(), frame->jsFrame->argValues<Value>(), argc, + frame->init(jsfo->function(), frame->jsFrame->argValues<Value>(), argc, frame->callerCanHandleTailCall()); - frame->setupJSFrame(frame->framePointer(), fo, fo.scope(), thisObject, + frame->setupJSFrame(frame->framePointer(), *jsfo, jsfo->scope(), thisObject, Primitive::undefinedValue()); engine->jsStackTop = frame->framePointer() + frame->requiredJSStackFrameSize(); frame->setPendingTailCall(true); diff --git a/src/qml/jsruntime/qv4setobject.cpp b/src/qml/jsruntime/qv4setobject.cpp index a7589a40db..e182015a32 100644 --- a/src/qml/jsruntime/qv4setobject.cpp +++ b/src/qml/jsruntime/qv4setobject.cpp @@ -14,14 +14,14 @@ DEFINE_OBJECT_VTABLE(SetCtor); DEFINE_OBJECT_VTABLE(WeakSetCtor); DEFINE_OBJECT_VTABLE(SetObject); -void Heap::WeakSetCtor::init(QV4::ExecutionContext *scope) +void Heap::WeakSetCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("WeakSet")); + Heap::FunctionObject::init(engine, QStringLiteral("WeakSet")); } -void Heap::SetCtor::init(QV4::ExecutionContext *scope) +void Heap::SetCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Set")); + Heap::FunctionObject::init(engine, QStringLiteral("Set")); } ReturnedValue WeakSetCtor::construct(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget, bool isWeak) diff --git a/src/qml/jsruntime/qv4setobject_p.h b/src/qml/jsruntime/qv4setobject_p.h index 6ed44b4ed9..5aa10f43c8 100644 --- a/src/qml/jsruntime/qv4setobject_p.h +++ b/src/qml/jsruntime/qv4setobject_p.h @@ -29,12 +29,12 @@ class ESTable; namespace Heap { struct WeakSetCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct SetCtor : WeakSetCtor { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct SetObject : Object { diff --git a/src/qml/jsruntime/qv4stringobject.cpp b/src/qml/jsruntime/qv4stringobject.cpp index ad3c39c7b9..5f3d833f33 100644 --- a/src/qml/jsruntime/qv4stringobject.cpp +++ b/src/qml/jsruntime/qv4stringobject.cpp @@ -131,9 +131,9 @@ PropertyAttributes StringObject::virtualGetOwnProperty(const Managed *m, Propert DEFINE_OBJECT_VTABLE(StringCtor); -void Heap::StringCtor::init(QV4::ExecutionContext *scope) +void Heap::StringCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("String")); + Heap::FunctionObject::init(engine, QStringLiteral("String")); } ReturnedValue StringCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget) diff --git a/src/qml/jsruntime/qv4stringobject_p.h b/src/qml/jsruntime/qv4stringobject_p.h index 451a989ef4..73c2bd7b34 100644 --- a/src/qml/jsruntime/qv4stringobject_p.h +++ b/src/qml/jsruntime/qv4stringobject_p.h @@ -44,7 +44,7 @@ DECLARE_HEAP_OBJECT(StringObject, Object) { }; struct StringCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(QV4::ExecutionEngine *engine); }; } diff --git a/src/qml/jsruntime/qv4symbol.cpp b/src/qml/jsruntime/qv4symbol.cpp index 5f7ec89fd2..85ef57f680 100644 --- a/src/qml/jsruntime/qv4symbol.cpp +++ b/src/qml/jsruntime/qv4symbol.cpp @@ -19,9 +19,9 @@ void Heap::Symbol::init(const QString &s) identifier = PropertyKey::fromStringOrSymbol(internalClass->engine, this); } -void Heap::SymbolCtor::init(QV4::ExecutionContext *scope) +void Heap::SymbolCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QStringLiteral("Symbol")); + Heap::FunctionObject::init(engine, QStringLiteral("Symbol")); } void Heap::SymbolObject::init(const QV4::Symbol *s) diff --git a/src/qml/jsruntime/qv4symbol_p.h b/src/qml/jsruntime/qv4symbol_p.h index e56510bd69..29a0189b69 100644 --- a/src/qml/jsruntime/qv4symbol_p.h +++ b/src/qml/jsruntime/qv4symbol_p.h @@ -25,7 +25,7 @@ namespace QV4 { namespace Heap { struct SymbolCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; struct Symbol : StringOrSymbol { diff --git a/src/qml/jsruntime/qv4typedarray.cpp b/src/qml/jsruntime/qv4typedarray.cpp index 6c72eaba5f..ca7d75e0e0 100644 --- a/src/qml/jsruntime/qv4typedarray.cpp +++ b/src/qml/jsruntime/qv4typedarray.cpp @@ -236,9 +236,9 @@ const TypedArrayOperations operations[NTypedArrayTypes] = { }; -void Heap::TypedArrayCtor::init(QV4::ExecutionContext *scope, TypedArray::Type t) +void Heap::TypedArrayCtor::init(QV4::ExecutionEngine *engine, TypedArray::Type t) { - Heap::FunctionObject::init(scope, QLatin1String(operations[t].name)); + Heap::FunctionObject::init(engine, QLatin1String(operations[t].name)); type = t; } diff --git a/src/qml/jsruntime/qv4typedarray_p.h b/src/qml/jsruntime/qv4typedarray_p.h index 9747eac411..50db9610c7 100644 --- a/src/qml/jsruntime/qv4typedarray_p.h +++ b/src/qml/jsruntime/qv4typedarray_p.h @@ -90,7 +90,7 @@ struct IntrinsicTypedArrayCtor : FunctionObject { }; struct TypedArrayCtor : FunctionObject { - void init(QV4::ExecutionContext *scope, TypedArray::Type t); + void init(ExecutionEngine *engine, TypedArray::Type t); TypedArray::Type type; }; @@ -141,8 +141,6 @@ struct IntrinsicTypedArrayCtor: FunctionObject { V4_OBJECT2(IntrinsicTypedArrayCtor, FunctionObject) - static constexpr VTable::Call virtualCall = nullptr; - static ReturnedValue method_of(const FunctionObject *, const Value *thisObject, const Value *argv, int argc); static ReturnedValue method_from(const FunctionObject *, const Value *thisObject, const Value *argv, int argc); }; diff --git a/src/qml/jsruntime/qv4urlobject.cpp b/src/qml/jsruntime/qv4urlobject.cpp index 4ece91a2a2..89c8b9cda2 100644 --- a/src/qml/jsruntime/qv4urlobject.cpp +++ b/src/qml/jsruntime/qv4urlobject.cpp @@ -18,9 +18,9 @@ DEFINE_OBJECT_VTABLE(UrlSearchParamsObject); DEFINE_OBJECT_VTABLE(UrlSearchParamsCtor); -void Heap::UrlCtor::init(QV4::ExecutionContext *scope) +void Heap::UrlCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QLatin1String("URL")); + Heap::FunctionObject::init(engine, QLatin1String("URL")); } void UrlPrototype::init(ExecutionEngine *engine, Object *ctor) @@ -750,9 +750,9 @@ ReturnedValue UrlCtor::virtualCallAsConstructor(const FunctionObject *that, cons } -void Heap::UrlSearchParamsCtor::init(QV4::ExecutionContext *scope) +void Heap::UrlSearchParamsCtor::init(QV4::ExecutionEngine *engine) { - Heap::FunctionObject::init(scope, QLatin1String("URLSearchParams")); + Heap::FunctionObject::init(engine, QLatin1String("URLSearchParams")); } void UrlSearchParamsPrototype::init(ExecutionEngine *engine, Object *ctor) diff --git a/src/qml/jsruntime/qv4urlobject_p.h b/src/qml/jsruntime/qv4urlobject_p.h index d45b74fcaa..b3b76e1158 100644 --- a/src/qml/jsruntime/qv4urlobject_p.h +++ b/src/qml/jsruntime/qv4urlobject_p.h @@ -47,7 +47,7 @@ DECLARE_HEAP_OBJECT(UrlObject, Object) struct UrlCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; // clang-format off @@ -66,7 +66,7 @@ DECLARE_HEAP_OBJECT(UrlSearchParamsObject, Object) struct UrlSearchParamsCtor : FunctionObject { - void init(QV4::ExecutionContext *scope); + void init(ExecutionEngine *engine); }; } diff --git a/src/qml/jsruntime/qv4value_p.h b/src/qml/jsruntime/qv4value_p.h index f2d01c56cd..eaa57a36aa 100644 --- a/src/qml/jsruntime/qv4value_p.h +++ b/src/qml/jsruntime/qv4value_p.h @@ -309,7 +309,10 @@ inline bool Value::isObject() const inline bool Value::isFunctionObject() const { HeapBasePtr b = heapObject(); - return b && b->internalClass->vtable->isFunctionObject; + if (!b) + return false; + const VTable *vtable = b->internalClass->vtable; + return vtable->call || vtable->callAsConstructor; } inline bool Value::isPrimitive() const diff --git a/src/qml/jsruntime/qv4vtable_p.h b/src/qml/jsruntime/qv4vtable_p.h index 8ec8c87a31..0532fdc32d 100644 --- a/src/qml/jsruntime/qv4vtable_p.h +++ b/src/qml/jsruntime/qv4vtable_p.h @@ -64,7 +64,7 @@ struct VTable quint8 isExecutionContext; quint8 isString; quint8 isObject; - quint8 isFunctionObject; + quint8 isTailCallable; quint8 isErrorObject; quint8 isArrayData; quint8 isStringOrSymbol; @@ -110,20 +110,38 @@ template<class Class> constexpr VTable::CallWithMetaTypes vtableMetaTypesCallEntry() { // If Class overrides virtualCallWithMetaTypes, return that. - // Otherwise, if it overrides virtualCall, return nullptr so that we convert calls. + // Otherwise, if it overrides virtualCall, return convertAndCall. // Otherwise, just return whatever the base class had. - // A simple != is not considered constexpr, so we have to jump through some hoops. - if constexpr (!std::is_same_v< - VTableCallWithMetaTypesWrapper<Class::virtualCallWithMetaTypes>, - VTableCallWithMetaTypesWrapper<Class::SuperClass::virtualCallWithMetaTypes>>) { - return Class::virtualCallWithMetaTypes; - } - - if constexpr (!std::is_same_v< - VTableCallWrapper<Class::virtualCall>, - VTableCallWrapper<Class::SuperClass::virtualCall>>) { - return nullptr; + // A simple == on methods is not considered constexpr, so we have to jump through some hoops. + + static_assert( + std::is_same_v< + VTableCallWithMetaTypesWrapper<Class::virtualCallWithMetaTypes>, + VTableCallWithMetaTypesWrapper<Class::SuperClass::virtualCallWithMetaTypes>> + || !std::is_same_v< + VTableCallWithMetaTypesWrapper<Class::virtualCallWithMetaTypes>, + VTableCallWithMetaTypesWrapper<nullptr>>, + "You mustn't override virtualCallWithMetaTypes with nullptr"); + + static_assert( + std::is_same_v< + VTableCallWithMetaTypesWrapper<Class::virtualConvertAndCall>, + VTableCallWithMetaTypesWrapper<Class::SuperClass::virtualConvertAndCall>> + || !std::is_same_v< + VTableCallWithMetaTypesWrapper<Class::virtualConvertAndCall>, + VTableCallWithMetaTypesWrapper<nullptr>>, + "You mustn't override virtualConvertAndCall with nullptr"); + + if constexpr ( + std::is_same_v< + VTableCallWithMetaTypesWrapper<Class::virtualCallWithMetaTypes>, + VTableCallWithMetaTypesWrapper<Class::SuperClass::virtualCallWithMetaTypes>> + && !std::is_same_v< + VTableCallWrapper<Class::virtualCall>, + VTableCallWrapper<Class::SuperClass::virtualCall>>) { + // Converting from metatypes to JS signature is easy. + return Class::virtualConvertAndCall; } return Class::virtualCallWithMetaTypes; @@ -133,21 +151,27 @@ template<class Class> constexpr VTable::Call vtableJsTypesCallEntry() { // If Class overrides virtualCall, return that. - // Otherwise, if it overrides virtualCallWithMetaTypes, return nullptr so that we convert calls. + // Otherwise, if it overrides virtualCallWithMetaTypes, fail. + // (We cannot determine the target types to call virtualCallWithMetaTypes in that case) // Otherwise, just return whatever the base class had. - // A simple != is not considered constexpr, so we have to jump through some hoops. - if constexpr (!std::is_same_v< - VTableCallWrapper<Class::virtualCall>, - VTableCallWrapper<Class::SuperClass::virtualCall>>) { - return Class::virtualCall; - } + // A simple == on methods is not considered constexpr, so we have to jump through some hoops. - if constexpr (!std::is_same_v< - VTableCallWithMetaTypesWrapper<Class::virtualCallWithMetaTypes>, - VTableCallWithMetaTypesWrapper<Class::SuperClass::virtualCallWithMetaTypes>>) { - return nullptr; - } + static_assert( + !std::is_same_v< + VTableCallWrapper<Class::virtualCall>, + VTableCallWrapper<Class::SuperClass::virtualCall>> + || std::is_same_v< + VTableCallWithMetaTypesWrapper<Class::virtualCallWithMetaTypes>, + VTableCallWithMetaTypesWrapper<Class::SuperClass::virtualCallWithMetaTypes>>, + "If you override virtualCallWithMetaTypes, override virtualCall, too"); + + static_assert( + std::is_same_v< + VTableCallWrapper<Class::virtualCall>, + VTableCallWrapper<Class::SuperClass::virtualCall>> + || VTableCallWrapper<Class::virtualCall>::c != nullptr, + "You mustn't override virtualCall with nullptr"); return Class::virtualCall; } @@ -174,6 +198,7 @@ protected: static constexpr VTable::Call virtualCall = nullptr; static constexpr VTable::CallAsConstructor virtualCallAsConstructor = nullptr; static constexpr VTable::CallWithMetaTypes virtualCallWithMetaTypes = nullptr; + static constexpr VTable::CallWithMetaTypes virtualConvertAndCall = nullptr; static constexpr VTable::ResolveLookupGetter virtualResolveLookupGetter = nullptr; static constexpr VTable::ResolveLookupSetter virtualResolveLookupSetter = nullptr; @@ -196,7 +221,7 @@ protected: classname::IsExecutionContext, \ classname::IsString, \ classname::IsObject, \ - classname::IsFunctionObject, \ + classname::IsTailCallable, \ classname::IsErrorObject, \ classname::IsArrayData, \ classname::IsStringOrSymbol, \ diff --git a/src/qml/parser/qqmljs.g b/src/qml/parser/qqmljs.g index 57954d7d1a..32b609f5ff 100644 --- a/src/qml/parser/qqmljs.g +++ b/src/qml/parser/qqmljs.g @@ -3399,6 +3399,7 @@ BindingProperty: PropertyName T_COLON BindingIdentifier InitializerOpt_In; case $rule_number: { AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, stringRef(3), sym(4).Expression); node->colonToken = loc(2); + node->identifierToken = loc(3); sym(1).Node = node; } break; ./ @@ -3567,6 +3568,11 @@ IterationStatement: T_FOR T_LPAREN LexicalDeclaration T_SEMICOLON ExpressionOpt_ AST::ForStatement *node = new (pool) AST::ForStatement( static_cast<AST::VariableStatement *>(sym(3).Node)->declarations, sym(5).Expression, sym(7).Expression, sym(9).Statement); + if (node->declarations) { + AST::PatternElement *pe = node->declarations->declaration; + pe->isForDeclaration = true; + pe->declarationKindToken = loc(3); + } node->forToken = loc(1); node->lparenToken = loc(2); node->firstSemicolonToken = loc(4); @@ -3638,6 +3644,7 @@ ForDeclaration: Var BindingIdentifier TypeAnnotationOpt; node->identifierToken = loc(2); node->scope = sym(1).scope; node->isForDeclaration = true; + node->declarationKindToken = loc(1); sym(1).Node = node; } break; ./ @@ -3650,6 +3657,7 @@ ForDeclaration: Var BindingPattern; auto *node = new (pool) AST::PatternElement(sym(2).Pattern, nullptr); node->scope = sym(1).scope; node->isForDeclaration = true; + node->declarationKindToken = loc(1); sym(1).Node = node; } break; ./ diff --git a/src/qml/parser/qqmljsast_p.h b/src/qml/parser/qqmljsast_p.h index 2bb9b3f001..bfeab7518c 100644 --- a/src/qml/parser/qqmljsast_p.h +++ b/src/qml/parser/qqmljsast_p.h @@ -995,6 +995,7 @@ public: Type type = Literal; TypeAnnotation *typeAnnotation = nullptr; // when used in a VariableDeclarationList + SourceLocation declarationKindToken; VariableScope scope = VariableScope::NoScope; bool isForDeclaration = false; bool isInjectedSignalParameter = false; diff --git a/src/qml/parser/qqmljslexer.cpp b/src/qml/parser/qqmljslexer.cpp index 704c7eb00d..cdb3dde5c6 100644 --- a/src/qml/parser/qqmljslexer.cpp +++ b/src/qml/parser/qqmljslexer.cpp @@ -1214,6 +1214,32 @@ int Lexer::scanString(ScanStringMode mode) int Lexer::scanNumber(QChar ch) { + auto scanOptionalNumericSeparator = [this](auto isNextCharacterValid){ + if (_state.currentChar == u'_') { + if (peekChar() == u'_') { + _state.errorCode = IllegalNumber; + _errorMessage = QCoreApplication::translate( + "QQmlParser", + "There can be at most one numeric separator beetwen digits" + ); + return false; + } + + if (!isNextCharacterValid()) { + _state.errorCode = IllegalNumber; + _errorMessage = QCoreApplication::translate( + "QQmlParser", + "A trailing numeric separator is not allowed in numeric literals" + ); + return false; + } + + scanChar(); + } + + return true; + }; + if (ch == u'0') { if (_state.currentChar == u'x' || _state.currentChar == u'X') { ch = _state.currentChar; // remember the x or X to use it in the error message below. @@ -1238,6 +1264,9 @@ int Lexer::scanNumber(QChar ch) d *= 16; d += digit; scanChar(); + + if (!scanOptionalNumericSeparator([this](){ return isHexDigit(peekChar()); })) + return T_ERROR; } _state.tokenValue = d; @@ -1265,6 +1294,12 @@ int Lexer::scanNumber(QChar ch) d *= 8; d += digit; scanChar(); + + if (!scanOptionalNumericSeparator([this](){ + return isOctalDigit(peekChar().unicode()); + })) { + return T_ERROR; + } } _state.tokenValue = d; @@ -1294,6 +1329,12 @@ int Lexer::scanNumber(QChar ch) d *= 2; d += digit; scanChar(); + + if (!scanOptionalNumericSeparator([this](){ + return peekChar().unicode() == u'0' || peekChar().unicode() == u'1'; + })) { + return T_ERROR; + } } _state.tokenValue = d; @@ -1311,9 +1352,15 @@ int Lexer::scanNumber(QChar ch) chars.append(ch.unicode()); if (ch != u'.') { + if (!scanOptionalNumericSeparator([this](){ return peekChar().isDigit(); })) + return T_ERROR; + while (_state.currentChar.isDigit()) { chars.append(_state.currentChar.unicode()); scanChar(); // consume the digit + + if (!scanOptionalNumericSeparator([this](){ return peekChar().isDigit(); })) + return T_ERROR; } if (_state.currentChar == u'.') { @@ -1325,6 +1372,9 @@ int Lexer::scanNumber(QChar ch) while (_state.currentChar.isDigit()) { chars.append(_state.currentChar.unicode()); scanChar(); + + if (!scanOptionalNumericSeparator([this](){ return peekChar().isDigit(); })) + return T_ERROR; } if (_state.currentChar == u'e' || _state.currentChar == u'E') { @@ -1342,6 +1392,9 @@ int Lexer::scanNumber(QChar ch) while (_state.currentChar.isDigit()) { chars.append(_state.currentChar.unicode()); scanChar(); + + if (!scanOptionalNumericSeparator([this](){ return peekChar().isDigit(); })) + return T_ERROR; } } } diff --git a/src/qml/qml/qqmlboundsignal.cpp b/src/qml/qml/qqmlboundsignal.cpp index 3f9ce26764..0bac2f45a2 100644 --- a/src/qml/qml/qqmlboundsignal.cpp +++ b/src/qml/qml/qqmlboundsignal.cpp @@ -62,7 +62,8 @@ QQmlBoundSignalExpression::QQmlBoundSignalExpression(const QObject *target, int function += QLatin1String(") { ") + expression + QLatin1String(" })"); QV4::Scope valueScope(v4); - QV4::ScopedFunctionObject f(valueScope, evalFunction(context(), scopeObject(), function, fileName, line)); + QV4::Scoped<QV4::JavaScriptFunctionObject> f( + valueScope, evalFunction(context(), scopeObject(), function, fileName, line)); QV4::ScopedContext context(valueScope, f->scope()); setupFunction(context, f->function()); } @@ -107,7 +108,7 @@ QQmlBoundSignalExpression::QQmlBoundSignalExpression(const QObject *target, int // we need to run the outer function to get the nested one. if (function->isClosureWrapper()) { bool isUndefined = false; - QV4::ScopedFunctionObject result( + QV4::Scoped<QV4::JavaScriptFunctionObject> result( valueScope, QQmlJavaScriptExpression::evaluate(&isUndefined)); Q_ASSERT(!isUndefined); diff --git a/src/qml/qml/qqmlbuiltinfunctions.cpp b/src/qml/qml/qqmlbuiltinfunctions.cpp index 5c6daa0969..a848dd536c 100644 --- a/src/qml/qml/qqmlbuiltinfunctions.cpp +++ b/src/qml/qml/qqmlbuiltinfunctions.cpp @@ -262,6 +262,9 @@ The \c status property will be updated as the operation progresses. If provided, \a callback is invoked when the operation completes. The callback is passed the same object as is returned from the Qt.include() call. + +\warning Using this function is strict mode does not actually put identifier into the +current context. */ // Qt.include() is implemented in qv4include.cpp @@ -1613,14 +1616,21 @@ QLocale QtObject::locale(const QString &name) const } #endif -void Heap::QQmlBindingFunction::init(const QV4::FunctionObject *bindingFunction) +void Heap::QQmlBindingFunction::init(const QV4::JavaScriptFunctionObject *bindingFunction) { Scope scope(bindingFunction->engine()); ScopedContext context(scope, bindingFunction->scope()); - FunctionObject::init(context, bindingFunction->function()); + JavaScriptFunctionObject::init(context, bindingFunction->function()); this->bindingFunction.set(internalClass->engine, bindingFunction->d()); } +ReturnedValue QQmlBindingFunction::virtualCall( + const FunctionObject *f, const Value *, const Value *, int) +{ + // Mark this as a callable object, so that we can perform the binding magic on it. + return f->engine()->throwTypeError(QStringLiteral("Bindings must not be called directly.")); +} + QQmlSourceLocation QQmlBindingFunction::currentLocation() const { QV4::CppStackFrame *frame = engine()->currentStackFrame; @@ -1675,7 +1685,8 @@ DEFINE_OBJECT_VTABLE(QQmlBindingFunction); */ QJSValue QtObject::binding(const QJSValue &function) const { - const QV4::FunctionObject *f = QJSValuePrivate::asManagedType<FunctionObject>(&function); + const QV4::JavaScriptFunctionObject *f + = QJSValuePrivate::asManagedType<JavaScriptFunctionObject>(&function); QV4::ExecutionEngine *e = v4Engine(); if (!f) { return QJSValuePrivate::fromReturnedValue( @@ -2138,7 +2149,7 @@ ReturnedValue GlobalExtensions::method_qsTranslate(const FunctionObject *b, cons } /*! - \qmlmethod string Qt::qsTranslateNoOp(string context, string sourceText, string disambiguation) + \qmlmethod string Qt::QT_TRANSLATE_NOOP(string context, string sourceText, string disambiguation) Marks \a sourceText for dynamic translation in the given \a context; i.e, the stored \a sourceText will not be altered. @@ -2253,7 +2264,7 @@ ReturnedValue GlobalExtensions::method_qsTr(const FunctionObject *b, const Value } /*! - \qmlmethod string Qt::qsTrNoOp(string sourceText, string disambiguation) + \qmlmethod string Qt::QT_TR_NOOP(string sourceText, string disambiguation) Marks \a sourceText for dynamic translation; i.e, the stored \a sourceText will not be altered. @@ -2334,7 +2345,7 @@ ReturnedValue GlobalExtensions::method_qsTrId(const FunctionObject *b, const Val } /*! - \qmlmethod string Qt::qsTrIdNoOp(string id) + \qmlmethod string Qt::QT_TRID_NOOP(string id) Marks \a id for dynamic translation. diff --git a/src/qml/qml/qqmlbuiltinfunctions_p.h b/src/qml/qml/qqmlbuiltinfunctions_p.h index 9ceedad28b..379b9b67ff 100644 --- a/src/qml/qml/qqmlbuiltinfunctions_p.h +++ b/src/qml/qml/qqmlbuiltinfunctions_p.h @@ -199,10 +199,10 @@ struct ConsoleObject : Object { }; #define QQmlBindingFunctionMembers(class, Member) \ - Member(class, Pointer, FunctionObject *, bindingFunction) -DECLARE_HEAP_OBJECT(QQmlBindingFunction, FunctionObject) { + Member(class, Pointer, JavaScriptFunctionObject *, bindingFunction) +DECLARE_HEAP_OBJECT(QQmlBindingFunction, JavaScriptFunctionObject) { DECLARE_MARKOBJECTS(QQmlBindingFunction) - void init(const QV4::FunctionObject *bindingFunction); + void init(const QV4::JavaScriptFunctionObject *bindingFunction); }; } @@ -245,11 +245,14 @@ struct Q_QML_EXPORT GlobalExtensions { }; -struct QQmlBindingFunction : public QV4::FunctionObject +struct QQmlBindingFunction : public QV4::JavaScriptFunctionObject { - V4_OBJECT2(QQmlBindingFunction, FunctionObject) + V4_OBJECT2(QQmlBindingFunction, JavaScriptFunctionObject) - Heap::FunctionObject *bindingFunction() const { return d()->bindingFunction; } + static ReturnedValue virtualCall( + const FunctionObject *f, const Value *thisObject, const Value *argv, int argc); + + Heap::JavaScriptFunctionObject *bindingFunction() const { return d()->bindingFunction; } QQmlSourceLocation currentLocation() const; // from caller stack trace }; diff --git a/src/qml/qml/qqmldelayedcallqueue.cpp b/src/qml/qml/qqmldelayedcallqueue.cpp index efd8519a58..ead8a717f5 100644 --- a/src/qml/qml/qqmldelayedcallqueue.cpp +++ b/src/qml/qml/qqmldelayedcallqueue.cpp @@ -126,8 +126,9 @@ QV4::ReturnedValue QQmlDelayedCallQueue::addUniquelyAndExecuteLater(QV4::Executi // if it's a qobject function wrapper, guard against qobject deletion dfc.m_objectGuard = QQmlGuard<QObject>(functionData.first); dfc.m_guarded = true; - } else if (func->scope()->type == QV4::Heap::ExecutionContext::Type_QmlContext) { - QV4::QmlContext::Data *g = static_cast<QV4::QmlContext::Data *>(func->scope()); + } else if (const auto *js = func->as<QV4::JavaScriptFunctionObject>(); + js && js->scope()->type == QV4::Heap::ExecutionContext::Type_QmlContext) { + QV4::QmlContext::Data *g = static_cast<QV4::QmlContext::Data *>(js->scope()); Q_ASSERT(g->qml()->scopeObject); dfc.m_objectGuard = QQmlGuard<QObject>(g->qml()->scopeObject); dfc.m_guarded = true; diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp index c7812059a1..62b7675e1d 100644 --- a/src/qml/qml/qqmlengine.cpp +++ b/src/qml/qml/qqmlengine.cpp @@ -1945,7 +1945,7 @@ void QQmlEnginePrivate::executeRuntimeFunction(const QV4::ExecutableCompilationU // different version of ExecutionEngine::callInContext() that returns a // QV4::ReturnedValue with no arguments since they are not needed by the // outer function anyhow - QV4::ScopedFunctionObject result(scope, + QV4::Scoped<QV4::JavaScriptFunctionObject> result(scope, v4->callInContext(function, thisObject, callContext, 0, nullptr)); Q_ASSERT(result->function()); Q_ASSERT(result->function()->compilationUnit == function->compilationUnit); diff --git a/src/qml/qml/qqmltypewrapper.cpp b/src/qml/qml/qqmltypewrapper.cpp index 0d8786a9df..4d62433ffd 100644 --- a/src/qml/qml/qqmltypewrapper.cpp +++ b/src/qml/qml/qqmltypewrapper.cpp @@ -28,10 +28,10 @@ void Heap::QQmlTypeWrapper::init(TypeNameMode m, QObject *o, const QQmlTypePriva { Q_ASSERT(type); Object::init(); - mode = m; + flags = quint8(m) | quint8(Type); object.init(o); - typePrivate = type; - QQmlType::refHandle(typePrivate); + QQmlType::refHandle(type); + t.typePrivate = type; } void Heap::QQmlTypeWrapper::init( @@ -39,27 +39,50 @@ void Heap::QQmlTypeWrapper::init( { Q_ASSERT(type); Object::init(); - mode = m; + flags = quint8(m) | quint8(Namespace); object.init(o); - typeNamespace = type; - typeNamespace->addref(); - importNamespace = import; + n.typeNamespace = type; + n.typeNamespace->addref(); + n.importNamespace = import; } void Heap::QQmlTypeWrapper::destroy() { - Q_ASSERT(typePrivate || typeNamespace); - QQmlType::derefHandle(typePrivate); - typePrivate = nullptr; - if (typeNamespace) - typeNamespace->release(); + switch (kind()) { + case Type: + Q_ASSERT(t.typePrivate); + QQmlType::derefHandle(t.typePrivate); + break; + case Namespace: + Q_ASSERT(n.typeNamespace); + n.typeNamespace->release(); + break; + } + object.destroy(); Object::destroy(); } QQmlType Heap::QQmlTypeWrapper::type() const { - return QQmlType(typePrivate); + switch (kind()) { + case Type: + return QQmlType(t.typePrivate); + case Namespace: + return QQmlType(); + } + + Q_UNREACHABLE_RETURN(QQmlType()); +} + +QQmlTypeNameCache::Result Heap::QQmlTypeWrapper::queryNamespace( + const QV4::String *name, QQmlEnginePrivate *enginePrivate) const +{ + Q_ASSERT(kind() == Namespace); + Q_ASSERT(n.typeNamespace); + Q_ASSERT(n.importNamespace); + return n.typeNamespace->query(name, n.importNamespace, QQmlTypeLoader::get(enginePrivate)); + } bool QQmlTypeWrapper::isSingleton() const @@ -203,7 +226,8 @@ ReturnedValue QQmlTypeWrapper::virtualGet(const Managed *m, PropertyKey id, cons if (type.isQObjectSingleton() || type.isCompositeSingleton()) { if (QObject *qobjectSingleton = enginePrivate->singletonInstance<QObject*>(type)) { // check for enum value - const bool includeEnums = w->d()->mode == Heap::QQmlTypeWrapper::IncludeEnums; + const bool includeEnums + = w->d()->typeNameMode() == Heap::QQmlTypeWrapper::IncludeEnums; if (includeEnums && name->startsWithUpper()) { bool ok = false; int value = enumForSingleton(v4, name, type, &ok); @@ -278,14 +302,11 @@ ReturnedValue QQmlTypeWrapper::virtualGet(const Managed *m, PropertyKey id, cons // Fall through to base implementation - } else if (w->d()->typeNamespace) { - Q_ASSERT(w->d()->importNamespace); - QQmlTypeNameCache::Result r = w->d()->typeNamespace->query( - name, w->d()->importNamespace, QQmlTypeLoader::get(enginePrivate)); - + } else if (w->d()->kind() == Heap::QQmlTypeWrapper::Namespace) { + const QQmlTypeNameCache::Result r = w->d()->queryNamespace(name, enginePrivate); if (r.isValid()) { if (r.type.isValid()) { - return create(scope.engine, object, r.type, w->d()->mode); + return create(scope.engine, object, r.type, w->d()->typeNameMode()); } else if (r.scriptIndex != -1) { QV4::ScopedObject scripts(scope, context->importedScripts().valueRef()); return scripts->get(r.scriptIndex); @@ -469,7 +490,8 @@ ReturnedValue QQmlTypeWrapper::virtualResolveLookupGetter(const Object *object, QQmlEnginePrivate *e = QQmlEnginePrivate::get(engine->qmlEngine()); if (type.isQObjectSingleton() || type.isCompositeSingleton()) { if (QObject *qobjectSingleton = e->singletonInstance<QObject*>(type)) { - const bool includeEnums = w->d()->mode == Heap::QQmlTypeWrapper::IncludeEnums; + const bool includeEnums + = w->d()->typeNameMode() == Heap::QQmlTypeWrapper::IncludeEnums; if (!includeEnums || !name->startsWithUpper()) { QQmlData *ddata = QQmlData::get(qobjectSingleton, false); if (ddata && ddata->propertyCache) { diff --git a/src/qml/qml/qqmltypewrapper_p.h b/src/qml/qml/qqmltypewrapper_p.h index 717efaf20e..a6837abc60 100644 --- a/src/qml/qml/qqmltypewrapper_p.h +++ b/src/qml/qml/qqmltypewrapper_p.h @@ -33,23 +33,44 @@ namespace QV4 { namespace Heap { struct QQmlTypeWrapper : Object { - enum TypeNameMode { - IncludeEnums, - ExcludeEnums + + enum TypeNameMode : quint8 { + ExcludeEnums = 0x0, + IncludeEnums = 0x1, + TypeNameModeMask = 0x1, + }; + + enum Kind : quint8 { + Type = 0x0, + Namespace = 0x2, + KindMask = 0x2 }; void init(TypeNameMode m, QObject *o, const QQmlTypePrivate *type); void init(TypeNameMode m, QObject *o, QQmlTypeNameCache *type, const QQmlImportRef *import); void destroy(); - TypeNameMode mode; + QQmlType type() const; + TypeNameMode typeNameMode() const { return TypeNameMode(flags & TypeNameModeMask); } + Kind kind() const { return Kind(flags & KindMask); } + + QQmlTypeNameCache::Result queryNamespace( + const QV4::String *name, QQmlEnginePrivate *enginePrivate) const; + QV4QPointer<QObject> object; - QQmlType type() const; + union { + struct { + const QQmlTypePrivate *typePrivate; + const void *reserved; + } t; + struct { + QQmlTypeNameCache *typeNamespace; + const QQmlImportRef *importNamespace; + } n; + }; - const QQmlTypePrivate *typePrivate; - QQmlTypeNameCache *typeNamespace; - const QQmlImportRef *importNamespace; + quint8 flags; }; struct QQmlScopedEnumWrapper : Object { diff --git a/src/qml/qml/qqmlvaluetypewrapper.cpp b/src/qml/qml/qqmlvaluetypewrapper.cpp index 7075d0f5f6..5c95ee28aa 100644 --- a/src/qml/qml/qqmlvaluetypewrapper.cpp +++ b/src/qml/qml/qqmlvaluetypewrapper.cpp @@ -304,7 +304,7 @@ static ReturnedValue getGadgetProperty(ExecutionEngine *engine, { if (isFunction) { // calling a Q_INVOKABLE function of a value type - return QV4::QObjectMethod::create(engine->rootContext(), valueTypeWrapper, coreIndex); + return QV4::QObjectMethod::create(engine, valueTypeWrapper, coreIndex); } const QMetaObject *metaObject = valueTypeWrapper->metaObject(); @@ -785,7 +785,7 @@ bool QQmlValueTypeWrapper::virtualPut(Managed *m, PropertyKey id, const Value &v QV4::Scoped<QQmlBindingFunction> bindingFunction(scope, (const Value &)f); - QV4::ScopedFunctionObject f(scope, bindingFunction->bindingFunction()); + QV4::Scoped<JavaScriptFunctionObject> f(scope, bindingFunction->bindingFunction()); QV4::ScopedContext ctx(scope, f->scope()); QQmlBinding *newBinding = QQmlBinding::create(&cacheData, f->function(), referenceObject, context, ctx); newBinding->setSourceLocation(bindingFunction->currentLocation()); diff --git a/src/qml/qml/qqmlvmemetaobject.cpp b/src/qml/qml/qqmlvmemetaobject.cpp index 5f3b6975ca..dffddd2e0d 100644 --- a/src/qml/qml/qqmlvmemetaobject.cpp +++ b/src/qml/qml/qqmlvmemetaobject.cpp @@ -1141,7 +1141,7 @@ int QQmlVMEMetaObject::metaCall(QObject *o, QMetaObject::Call c, int _id, void * QV4::Scope scope(v4); - QV4::ScopedFunctionObject function(scope, method(id)); + QV4::Scoped<QV4::JavaScriptFunctionObject> function(scope, method(id)); if (!function) { // The function was not compiled. There are some exceptional cases which the // expression rewriter does not rewrite properly (e.g., \r-terminated lines diff --git a/src/qml/qml/qqmlxmlhttprequest.cpp b/src/qml/qml/qqmlxmlhttprequest.cpp index c5d18860db..b4800584a3 100644 --- a/src/qml/qml/qqmlxmlhttprequest.cpp +++ b/src/qml/qml/qqmlxmlhttprequest.cpp @@ -1708,7 +1708,7 @@ DEFINE_OBJECT_VTABLE(QQmlXMLHttpRequestWrapper); void Heap::QQmlXMLHttpRequestCtor::init(ExecutionEngine *engine) { - Heap::FunctionObject::init(engine->rootContext(), QStringLiteral("XMLHttpRequest")); + Heap::FunctionObject::init(engine, QStringLiteral("XMLHttpRequest")); Scope scope(engine); Scoped<QV4::QQmlXMLHttpRequestCtor> ctor(scope, this); diff --git a/src/qml/qqmlbuiltins_p.h b/src/qml/qqmlbuiltins_p.h index edf2579760..43e3a70dff 100644 --- a/src/qml/qqmlbuiltins_p.h +++ b/src/qml/qqmlbuiltins_p.h @@ -35,6 +35,7 @@ #include <QtCore/qvariantmap.h> #include <QtCore/qtypes.h> #include <QtCore/qchar.h> +#include <QtCore/qjsonobject.h> #include <climits> @@ -337,6 +338,14 @@ struct QQmlQByteArrayForeign QML_FOREIGN(QByteArray) }; +struct QQmlQByteArrayListForeign +{ + Q_GADGET + QML_ANONYMOUS + QML_FOREIGN(QByteArrayList) + QML_SEQUENTIAL_CONTAINER(QByteArray) +}; + struct QQmlQStringListForeign { Q_GADGET @@ -393,6 +402,14 @@ struct QQmlV4FunctionPtrForeign QML_EXTENDED(QQmlV4FunctionPtrForeign) }; +struct QQmlQJsonObjectForeign +{ + Q_GADGET + QML_ANONYMOUS + QML_FOREIGN(QJsonObject) + QML_EXTENDED_JAVASCRIPT(Object) +}; + QT_END_NAMESPACE #endif // QQMLBUILTINS_H diff --git a/src/qml/types/qqmlconnections.cpp b/src/qml/types/qqmlconnections.cpp index 19363f9f76..99541a64dc 100644 --- a/src/qml/types/qqmlconnections.cpp +++ b/src/qml/types/qqmlconnections.cpp @@ -415,13 +415,12 @@ void QQmlConnections::connectSignalsToMethods() auto *signal = new QQmlBoundSignal(target, signalIndex, this, qmlEngine(this)); signal->setEnabled(d->enabled); - QV4::ScopedFunctionObject method( + QV4::Scoped<QV4::JavaScriptFunctionObject> method( scope, vmeMetaObject->vmeMethod(handler->coreIndex())); QQmlBoundSignalExpression *expression = ctxtdata ? new QQmlBoundSignalExpression( - target, signalIndex, ctxtdata, this, - method->as<QV4::FunctionObject>()->function()) + target, signalIndex, ctxtdata, this, method->function()) : nullptr; signal->takeExpression(expression); |