qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtdeclarative/tests/auto/qml/qqmljsscope/tst_qqmljsscope.cpp

794 lines
33 KiB
C++
Raw Normal View History

Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
/****************************************************************************
**
** Copyright (C) 2021 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtTest/QtTest>
#include <QtQuickTestUtils/private/qmlutils_p.h>
#include <QtCore/qfileinfo.h>
#include <QtCore/qdir.h>
#include <QtCore/qdiriterator.h>
#include <QtCore/qurl.h>
#include <QtCore/qlibraryinfo.h>
tst_qqmljsscope: Cover a more sophisticated group property case Document (via test) what happens when we re-assign a group property in the derived scope Introduce a QML test module along the way used within the test As a drive by, add all QML test files to TESTDATA Change-Id: Id4c3e20e45b8e0f3757840c87e0285f8516319a8 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-03-30 10:50:46 +00:00
#include <QtCore/qscopedpointer.h>
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
#include <QtQml/qqmlengine.h>
#include <QtQml/qqmlcomponent.h>
tst_qqmljsscope: Cover a more sophisticated group property case Document (via test) what happens when we re-assign a group property in the derived scope Introduce a QML test module along the way used within the test As a drive by, add all QML test files to TESTDATA Change-Id: Id4c3e20e45b8e0f3757840c87e0285f8516319a8 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-03-30 10:50:46 +00:00
#include <QtGui/qfont.h>
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
#include <QtQml/private/qqmlirbuilder_p.h>
#include <private/qqmljscompiler_p.h>
#include <private/qqmljsscope_p.h>
#include <private/qqmljsimporter_p.h>
#include <private/qqmljslogger_p.h>
#include <private/qqmljsimportvisitor_p.h>
#include <private/qqmljstyperesolver_p.h>
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
#include <QtQml/private/qqmljslexer_p.h>
#include <QtQml/private/qqmljsparser_p.h>
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
using namespace Qt::StringLiterals;
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
class tst_qqmljsscope : public QQmlDataTest
{
Q_OBJECT
QString loadUrl(const QString &url)
{
const QFileInfo fi(url);
QFile f(fi.absoluteFilePath());
f.open(QIODevice::ReadOnly);
QByteArray data(fi.size(), Qt::Uninitialized);
f.read(data.data(), data.length());
return QString::fromUtf8(data);
}
QQmlJSImportVisitor: do not register group { ... } as an object scope Grouped properties do not bind to a default property and they are not object definition scopes. Fix the subtle issue where we'd do the opposite for `group { ... }` syntax Submit the tst_qqmljsscope changes that made the issue visible Pick-to: 6.3 Change-Id: I314b19d5cad62f70146d228e5402c9fc73b309ad Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-04 10:35:58 +00:00
QQmlJSScope::ConstPtr run(QString url, bool expectErrorsOrWarnings = false)
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
{
QmlIR::Document document(false);
QQmlJSImportVisitor: do not register group { ... } as an object scope Grouped properties do not bind to a default property and they are not object definition scopes. Fix the subtle issue where we'd do the opposite for `group { ... }` syntax Submit the tst_qqmljsscope changes that made the issue visible Pick-to: 6.3 Change-Id: I314b19d5cad62f70146d228e5402c9fc73b309ad Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-04 10:35:58 +00:00
return run(url, &document, expectErrorsOrWarnings);
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
}
QQmlJSImportVisitor: do not register group { ... } as an object scope Grouped properties do not bind to a default property and they are not object definition scopes. Fix the subtle issue where we'd do the opposite for `group { ... }` syntax Submit the tst_qqmljsscope changes that made the issue visible Pick-to: 6.3 Change-Id: I314b19d5cad62f70146d228e5402c9fc73b309ad Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-04 10:35:58 +00:00
QQmlJSScope::ConstPtr run(QString url, QmlIR::Document *document,
bool expectErrorsOrWarnings = false)
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
{
url = testFile(url);
const QString sourceCode = loadUrl(url);
if (sourceCode.isEmpty())
return QQmlJSScope::ConstPtr();
// NB: JS unit generated here is ignored, so use noop function
QQmlJSSaveFunction noop([](auto &&...) { return true; });
QQmlJSCompileError error;
[&]() {
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
QVERIFY2(qCompileQmlFile(*document, url, noop, nullptr, &error),
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
qPrintable(error.message));
}();
if (!error.message.isEmpty())
return QQmlJSScope::ConstPtr();
Add a default implementation for QQmlJSAotCompiler The default AOT compiler compiles QML code in indirect, dynamic mode. It uses the logger's Log_Compiler category to determine the verbosity of its output. In addition you can use the qt.qml.compiler.aot category for even more verbosity. In preparation for using QQmlJSAotCompiler with qmlcachegen, the default level of that category is increased to QtFatalMsg. The highest level we actually output is QtDebugMsg, so it doesn't make a difference yet. If the logger's Log_Compiler category is set to produce errors, it will qFatal() on "pragma Strict" violations. Change-Id: Ieb74bfa7cd51cfa8616792ab467c32f6ba0e0702 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-18 13:26:29 +00:00
QQmlJSLogger logger;
logger.setFileName(url);
logger.setCode(sourceCode);
QQmlJSImportVisitor: do not register group { ... } as an object scope Grouped properties do not bind to a default property and they are not object definition scopes. Fix the subtle issue where we'd do the opposite for `group { ... }` syntax Submit the tst_qqmljsscope changes that made the issue visible Pick-to: 6.3 Change-Id: I314b19d5cad62f70146d228e5402c9fc73b309ad Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-04 10:35:58 +00:00
logger.setSilent(expectErrorsOrWarnings);
Avoid copying QQmlJSScope The factory should populate the pre-existing scope rather than copy it into place. This way we can detect inheritance cycles involving the pre-existing scope. However, now we may detect the inheritance cycles earlier, when resolving the types inside the lazy loading. We have the right pointers available there now, after all. Therefore, add a way to propagate base type errors out of the factory. When clearing the base type, we can now give a reason for that. When checking the inheritance cycles we retrieve that reason and log it. We also remove the special casing of the ScopeType property of QQmlJSScope. There is no real reason to set it in the ctor. As we delay the population of QQmlJSScope now, we have to set it later. Pick-to: 6.2 6.3 Task-number: QTBUG-102153 Change-Id: I49cf6e20f59fbdb6ed98a82040b3b159676f5975 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-31 09:26:09 +00:00
QQmlJSScope::Ptr target = QQmlJSScope::create();
QQmlJSImportVisitor visitor(target, &m_importer, &logger, dataDirectory());
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
QQmlJSTypeResolver typeResolver { &m_importer };
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
typeResolver.init(&visitor, document->program);
QQmlJSImportVisitor: do not register group { ... } as an object scope Grouped properties do not bind to a default property and they are not object definition scopes. Fix the subtle issue where we'd do the opposite for `group { ... }` syntax Submit the tst_qqmljsscope changes that made the issue visible Pick-to: 6.3 Change-Id: I314b19d5cad62f70146d228e5402c9fc73b309ad Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-04 10:35:58 +00:00
if (!expectErrorsOrWarnings) {
[&]() {
QVERIFY2(!logger.hasWarnings(), "Expected no warnings in this test");
QVERIFY2(!logger.hasErrors(), "Expected no errors in this test");
}();
}
if (QTest::currentTestFailed())
return QQmlJSScope::ConstPtr();
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
return visitor.result();
}
private Q_SLOTS:
void initTestCase() override;
void orderedBindings();
Distinguish property change signals from user-defined signals Do not expose this information to qmltypes just yet, though, as this seems irrelevant at the moment Pick-to: 6.3 Change-Id: Iffd8901ef9899a0fff226e8799bf45c1d688b92b Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-01-27 14:02:00 +00:00
void signalCreationDifferences();
QmlCompiler: Discern between internal and anonymous imports Anonymous imports are imports of QML types that aren't visible in the current document. Internal imports are imports of C++ types, also invisible, but potentially of the same names. Before, types with exports were added to the qmltypes container using their exports if any matched. If there were no exports, we constructed a synthetic name and inserted that. However, as the nullptr example shows, we need a reliable way to find them by their internal names, no matter if exports are present. Therefore, we now consistently add them by their internal names using the new $internal$ prefix. Change-Id: I42ac2447cd924d09970c24554e1e2a5e631c5f79 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-03 13:39:58 +00:00
void allTypesAvailable();
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
void shadowing();
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
#ifdef LABS_QML_MODELS_PRESENT
void componentWrappedObjects();
Add QmlModels dependency to LabsQmlModels Some classes (e.g. QQmlDelegateChooser) depend-on / inherit QmlModels' functionality. We need to propagate that dependency to QML via qmldir entry, otherwise we won't be able to see the types in QmlCompiler lib Note that we already depend more strongly (via linking) on the QmlModels library, so there is no reason not to depend on the QML module in qmldir Pick-to: 6.2 6.3 Change-Id: I4f16f66f2910fb6afd38475cd6ba3209cfd1207d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-28 11:45:35 +00:00
void labsQmlModelsSanity();
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
#endif
void unknownCppBase();
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
void groupedProperties();
QmlCompiler: Allow retrieval of descriptive name from invalid types Apparently we do that somewhere. It should not just crash. Pick-to: 6.2 6.3 Task-number: QTBUG-102147 Change-Id: Id612e0543d8794aa4f334a899b117142b7a8cd38 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-06 09:52:25 +00:00
void descriptiveNameOfNull();
tst_qqmljsscope: Cover a more sophisticated group property case Document (via test) what happens when we re-assign a group property in the derived scope Introduce a QML test module along the way used within the test As a drive by, add all QML test files to TESTDATA Change-Id: Id4c3e20e45b8e0f3757840c87e0285f8516319a8 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-03-30 10:50:46 +00:00
void groupedPropertiesConsistency();
qmlcompiler: Create group binding in group property syntax case Cover the following case of binding on a group property: Type { group { foo: 42 } } Task-number: QTBUG-100168 Change-Id: I0147c74dffb649907457d5f17a2ab29473101a6d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 12:15:32 +00:00
void groupedPropertySyntax();
qmlcompiler: Support attached property bindings Extend group property binding creation with attached properties case As a drive by, add extra attached property tests for QML and qmltc, covering the case where an attaching type exists in both base and derived types Task-number: QTBUG-102082 Change-Id: I6c0d2b941da72d6dab7fc05a4f7b2a7875423ef0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 15:16:11 +00:00
void attachedProperties();
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
void scriptIndices();
Fix extension lookup in QQmlJSScope Do not go over extension's base types since this is not how the engine logic work. Instead, only assess the direct extension type when traversing the base type hierarchy. The special cases are value types which still need base type extension traversal (e.g. due to Number and NumberPrototype extensions on primitives) and QObject type itself (we expect to see ObjectPrototype properties / methods of it) Pick-to: 6.3 6.2 Change-Id: I92ba979202b33f16e1a7b948d4f1e79df37f2669 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-03 15:08:37 +00:00
void extensions();
qqmljsimportvisitor: Fix assert being hit on empty block bindings We previously hit an assert / crashed if we saw an empty script binding. Fixes: QTBUG-103707 Change-Id: I117d984a7d315ecf860d2ada5568637d154ae083 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-05-19 13:41:24 +00:00
void emptyBlockBinding();
qmlcompiler: Add qualified name to QQmlJSScope Added moduleName and qualifiedName to QQmlJSScope. Those properties are written in the scopes after they were loaded by readQmlDir. Fixes: QTBUG-103299 Change-Id: I3b2c68c43c3bf0ac6cf801b0e54cf4b412b4d4e5 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-05-19 08:35:20 +00:00
void qualifiedName();
Set bindings on QQmlJSScope after AST traversal We can get into situations when binding creation is problematic due to the relevant scopes being yet unresolved. In particular, this happens when processing attached/group properties script bindings Avoid having this situation by postponing the actual binding setting until after the relavant scopes are resolved (mainly, the binding owner). However, do relevant AST order dependent operations beforehand to avoid accidental errors This commit amends 25098b7a4fdb8920874a817956f659e6393548d2 Fixes: QTBUG-103897 Change-Id: I671955dbe321d03e5f1ab9891cc79dc0a936deda Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-25 13:18:56 +00:00
void resolvedNonUniqueScopes();
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
public:
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
tst_qqmljsscope()
: QQmlDataTest(QT_QMLTEST_DATADIR),
m_importer(
{
QLibraryInfo::path(QLibraryInfo::QmlImportsPath),
dataDirectory(),
tst_qqmljsscope: Fix test module importing The name of the module's folder should match the URI and application binary dir should be provided as an extra import path for the module to be discoverable Change-Id: I00d67593d18dc86c0929f8a64b2c165221a4758a Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-04 12:13:09 +00:00
// Note: to be able to import the QQmlJSScopeTests
// correctly, we need an additional import path. Use
// this application's binary directory as done by
// QQmlImportDatabase
QCoreApplication::applicationDirPath(),
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
},
nullptr)
{
}
private:
QQmlJSImporter m_importer;
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
};
void tst_qqmljsscope::initTestCase()
{
QQmlDataTest::initTestCase();
QDirIterator it(dataDirectory(), QDirIterator::FollowSymlinks | QDirIterator::Subdirectories);
while (it.hasNext()) {
const QString url = it.next();
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
if (!url.endsWith(u".qml"_s)) // not interesting
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
continue;
const QFileInfo fi(url);
QVERIFY(fi.exists());
QFile f(fi.absoluteFilePath());
QVERIFY(f.open(QIODevice::ReadOnly));
}
tst_qqmljsscope: Fix test module importing The name of the module's folder should match the URI and application binary dir should be provided as an extra import path for the module to be discoverable Change-Id: I00d67593d18dc86c0929f8a64b2c165221a4758a Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-04 12:13:09 +00:00
// test that we can import the module shipped with this test: if we have no
// errors / warnings, it is a success
QVERIFY(run(u"importOwnModule.qml"_s));
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
}
void tst_qqmljsscope::orderedBindings()
{
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QQmlJSScope::ConstPtr root = run(u"orderedBindings.qml"_s);
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
QVERIFY(root);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
auto [pBindingsBegin, pBindingsEnd] = root->ownPropertyBindings(u"p"_s);
qqmljsimportvisitor: Fix assert being hit on empty block bindings We previously hit an assert / crashed if we saw an empty script binding. Fixes: QTBUG-103707 Change-Id: I117d984a7d315ecf860d2ada5568637d154ae083 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-05-19 13:41:24 +00:00
QCOMPARE(std::distance(pBindingsBegin, pBindingsEnd), 2);
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
// check that the bindings are properly ordered
QCOMPARE(pBindingsBegin->bindingType(), QQmlJSMetaPropertyBinding::Object);
QCOMPARE(std::next(pBindingsBegin)->bindingType(), QQmlJSMetaPropertyBinding::Interceptor);
QQmlJSImportVisitor: record UiArrayBinding as binding UiArrayBinding stores object bindings for list<Type> properties (where Type is, or is derived from, QtObject) Test the change both in qmllint (with an ordinary "it reports warnings when needed") and by introspecting QQmlJSScope. In the latter case we can also ensure that the bindings are recorded in the correct order Fixes: QTBUG-93358 Change-Id: Ib5544ba339e22ea899191483a5ba53f755314daa Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-24 08:53:10 +00:00
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
auto [itemsBindingsBegin, itemsBindingsEnd] = root->ownPropertyBindings(u"items"_s);
qqmljsimportvisitor: Fix assert being hit on empty block bindings We previously hit an assert / crashed if we saw an empty script binding. Fixes: QTBUG-103707 Change-Id: I117d984a7d315ecf860d2ada5568637d154ae083 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-05-19 13:41:24 +00:00
QCOMPARE(std::distance(itemsBindingsBegin, itemsBindingsEnd), 2);
QQmlJSImportVisitor: record UiArrayBinding as binding UiArrayBinding stores object bindings for list<Type> properties (where Type is, or is derived from, QtObject) Test the change both in qmllint (with an ordinary "it reports warnings when needed") and by introspecting QQmlJSScope. In the latter case we can also ensure that the bindings are recorded in the correct order Fixes: QTBUG-93358 Change-Id: Ib5544ba339e22ea899191483a5ba53f755314daa Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-24 08:53:10 +00:00
QCOMPARE(itemsBindingsBegin->bindingType(), QQmlJSMetaPropertyBinding::Object);
QCOMPARE(std::next(itemsBindingsBegin)->bindingType(), QQmlJSMetaPropertyBinding::Object);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(itemsBindingsBegin->objectType()->baseTypeName(), u"Item"_s);
QCOMPARE(std::next(itemsBindingsBegin)->objectType()->baseTypeName(), u"Text"_s);
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
}
Distinguish property change signals from user-defined signals Do not expose this information to qmltypes just yet, though, as this seems irrelevant at the moment Pick-to: 6.3 Change-Id: Iffd8901ef9899a0fff226e8799bf45c1d688b92b Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-01-27 14:02:00 +00:00
void tst_qqmljsscope::signalCreationDifferences()
{
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QQmlJSScope::ConstPtr root = run(u"signalCreationDifferences.qml"_s);
Distinguish property change signals from user-defined signals Do not expose this information to qmltypes just yet, though, as this seems irrelevant at the moment Pick-to: 6.3 Change-Id: Iffd8901ef9899a0fff226e8799bf45c1d688b92b Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-01-27 14:02:00 +00:00
QVERIFY(root);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QVERIFY(root->hasOwnProperty(u"myProperty"_s));
QVERIFY(root->hasOwnProperty(u"conflictingProperty"_s));
QCOMPARE(root->ownMethods(u"mySignal"_s).size(), 1);
Distinguish property change signals from user-defined signals Do not expose this information to qmltypes just yet, though, as this seems irrelevant at the moment Pick-to: 6.3 Change-Id: Iffd8901ef9899a0fff226e8799bf45c1d688b92b Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-01-27 14:02:00 +00:00
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
const auto conflicting = root->ownMethods(u"conflictingPropertyChanged"_s);
Distinguish property change signals from user-defined signals Do not expose this information to qmltypes just yet, though, as this seems irrelevant at the moment Pick-to: 6.3 Change-Id: Iffd8901ef9899a0fff226e8799bf45c1d688b92b Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-01-27 14:02:00 +00:00
QCOMPARE(conflicting.size(), 2);
QCOMPARE(conflicting[0].methodType(), QQmlJSMetaMethod::Signal);
QCOMPARE(conflicting[1].methodType(), QQmlJSMetaMethod::Signal);
const QQmlJSMetaMethod *explicitMethod = nullptr;
if (conflicting[0].isImplicitQmlPropertyChangeSignal())
explicitMethod = &conflicting[1];
else
explicitMethod = &conflicting[0];
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(explicitMethod->parameterNames(), QStringList({ u"a"_s, u"c"_s }));
Distinguish property change signals from user-defined signals Do not expose this information to qmltypes just yet, though, as this seems irrelevant at the moment Pick-to: 6.3 Change-Id: Iffd8901ef9899a0fff226e8799bf45c1d688b92b Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-01-27 14:02:00 +00:00
}
QmlCompiler: Discern between internal and anonymous imports Anonymous imports are imports of QML types that aren't visible in the current document. Internal imports are imports of C++ types, also invisible, but potentially of the same names. Before, types with exports were added to the qmltypes container using their exports if any matched. If there were no exports, we constructed a synthetic name and inserted that. However, as the nullptr example shows, we need a reliable way to find them by their internal names, no matter if exports are present. Therefore, we now consistently add them by their internal names using the new $internal$ prefix. Change-Id: I42ac2447cd924d09970c24554e1e2a5e631c5f79 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-03 13:39:58 +00:00
void tst_qqmljsscope::allTypesAvailable()
{
const QStringList importPaths = {
QLibraryInfo::path(QLibraryInfo::QmlImportsPath),
dataDirectory(),
};
QQmlJSImporter importer { importPaths, /* resource file mapper */ nullptr };
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
const auto types = importer.importModule(u"QtQml"_s);
QVERIFY(types.contains(u"$internal$.QObject"_s));
QVERIFY(types.contains(u"QtObject"_s));
QCOMPARE(types[u"$internal$.QObject"_s].scope, types[u"QtObject"_s].scope);
QmlCompiler: Discern between internal and anonymous imports Anonymous imports are imports of QML types that aren't visible in the current document. Internal imports are imports of C++ types, also invisible, but potentially of the same names. Before, types with exports were added to the qmltypes container using their exports if any matched. If there were no exports, we constructed a synthetic name and inserted that. However, as the nullptr example shows, we need a reliable way to find them by their internal names, no matter if exports are present. Therefore, we now consistently add them by their internal names using the new $internal$ prefix. Change-Id: I42ac2447cd924d09970c24554e1e2a5e631c5f79 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-03 13:39:58 +00:00
}
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
void tst_qqmljsscope::shadowing()
{
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QQmlJSScope::ConstPtr root = run(u"shadowing.qml"_s);
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
QVERIFY(root);
QVERIFY(root->baseType());
// Check whether properties are properly shadowed
const auto properties = root->properties();
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QVERIFY(properties.contains(u"property_not_shadowed"_s));
QVERIFY(properties.contains(u"property_shadowed"_s));
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(properties[u"property_not_shadowed"_s].typeName(), u"QString"_s);
QCOMPARE(properties[u"property_shadowed"_s].typeName(), u"int"_s);
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
// Check whether methods are properly shadowed
const auto methods = root->methods();
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(methods.count(u"method_not_shadowed"_s), 1);
QCOMPARE(methods.count(u"method_shadowed"_s), 1);
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(methods[u"method_not_shadowed"_s].parameterNames().size(), 1);
QCOMPARE(methods[u"method_shadowed"_s].parameterNames().size(), 0);
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
}
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
#ifdef LABS_QML_MODELS_PRESENT
void tst_qqmljsscope::componentWrappedObjects()
{
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QQmlJSScope::ConstPtr root = run(u"componentWrappedObjects.qml"_s);
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
QVERIFY(root);
auto children = root->childScopes();
QCOMPARE(children.size(), 4);
const auto isGoodType = [](const QQmlJSScope::ConstPtr &type, const QString &propertyName,
bool isWrapped) {
return type->hasOwnProperty(propertyName)
&& type->isWrappedInImplicitComponent() == isWrapped;
};
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QVERIFY(isGoodType(children[0], u"nonWrapped1"_s, false));
QVERIFY(isGoodType(children[1], u"nonWrapped2"_s, false));
QVERIFY(isGoodType(children[2], u"nonWrapped3"_s, false));
QVERIFY(isGoodType(children[3], u"wrapped"_s, true));
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
}
Add QmlModels dependency to LabsQmlModels Some classes (e.g. QQmlDelegateChooser) depend-on / inherit QmlModels' functionality. We need to propagate that dependency to QML via qmldir entry, otherwise we won't be able to see the types in QmlCompiler lib Note that we already depend more strongly (via linking) on the QmlModels library, so there is no reason not to depend on the QML module in qmldir Pick-to: 6.2 6.3 Change-Id: I4f16f66f2910fb6afd38475cd6ba3209cfd1207d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-28 11:45:35 +00:00
void tst_qqmljsscope::labsQmlModelsSanity()
{
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QQmlJSScope::ConstPtr root = run(u"labsQmlModelsSanity.qml"_s);
Add QmlModels dependency to LabsQmlModels Some classes (e.g. QQmlDelegateChooser) depend-on / inherit QmlModels' functionality. We need to propagate that dependency to QML via qmldir entry, otherwise we won't be able to see the types in QmlCompiler lib Note that we already depend more strongly (via linking) on the QmlModels library, so there is no reason not to depend on the QML module in qmldir Pick-to: 6.2 6.3 Change-Id: I4f16f66f2910fb6afd38475cd6ba3209cfd1207d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-28 11:45:35 +00:00
QVERIFY(root);
auto children = root->childScopes();
QCOMPARE(children.size(), 1);
// DelegateChooser: it inherits QQmlAbstractDelegateComponent (from
// QmlModels) which inherits QQmlComponent. While
// QQmlAbstractDelegateComponent has no properties, QQmlComponent does. If
// the QmlModels dependency is lost, we don't "see" that DelegateChooser
// inherits QQmlComponent - and so has no properties from it, hence, we can
// test exactly that:
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QVERIFY(children[0]->hasProperty(u"progress"_s));
QVERIFY(children[0]->hasProperty(u"status"_s));
QVERIFY(children[0]->hasProperty(u"url"_s));
Add QmlModels dependency to LabsQmlModels Some classes (e.g. QQmlDelegateChooser) depend-on / inherit QmlModels' functionality. We need to propagate that dependency to QML via qmldir entry, otherwise we won't be able to see the types in QmlCompiler lib Note that we already depend more strongly (via linking) on the QmlModels library, so there is no reason not to depend on the QML module in qmldir Pick-to: 6.2 6.3 Change-Id: I4f16f66f2910fb6afd38475cd6ba3209cfd1207d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-28 11:45:35 +00:00
}
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
#endif
void tst_qqmljsscope::unknownCppBase()
{
QQmlJSImportVisitor: do not register group { ... } as an object scope Grouped properties do not bind to a default property and they are not object definition scopes. Fix the subtle issue where we'd do the opposite for `group { ... }` syntax Submit the tst_qqmljsscope changes that made the issue visible Pick-to: 6.3 Change-Id: I314b19d5cad62f70146d228e5402c9fc73b309ad Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-04 10:35:58 +00:00
QQmlJSScope::ConstPtr root = run(u"unknownCppBaseAssigningToVar.qml"_s, true);
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
QVERIFY(root);
// we should not crash here, then it is a success
}
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
void tst_qqmljsscope::groupedProperties()
{
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QQmlJSScope::ConstPtr root = run(u"groupProperties.qml"_s);
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
QVERIFY(root);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QVERIFY(root->hasProperty(u"anchors"_s));
const auto anchorBindings = root->propertyBindings(u"anchors"_s);
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
QVERIFY(!anchorBindings.isEmpty());
QQmlJSMetaPropertyBinding:add group type fetching function, extend tests Change-Id: I754349ab5b6a8125ccc373210fc073dd71583c6f Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-29 15:19:36 +00:00
QCOMPARE(anchorBindings.size(), 2); // from type itself and from the base type
const auto getBindingsWithinGroup =
[&](QMultiHash<QString, QQmlJSMetaPropertyBinding> *bindings, qsizetype index) -> void {
const auto &binding = anchorBindings[index];
QCOMPARE(binding.bindingType(), QQmlJSMetaPropertyBinding::GroupProperty);
auto anchorScope = binding.groupType();
QVERIFY(anchorScope);
*bindings = anchorScope->ownPropertyBindings();
};
const auto value = [](const QMultiHash<QString, QQmlJSMetaPropertyBinding> &bindings,
const QString &key) {
return bindings.value(key, QQmlJSMetaPropertyBinding(QQmlJS::SourceLocation {}));
};
QMultiHash<QString, QQmlJSMetaPropertyBinding> bindingsOfType;
getBindingsWithinGroup(&bindingsOfType, 0);
QCOMPARE(bindingsOfType.size(), 2);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(value(bindingsOfType, u"left"_s).bindingType(), QQmlJSMetaPropertyBinding::Script);
QCOMPARE(value(bindingsOfType, u"leftMargin"_s).bindingType(),
QQmlJSMetaPropertyBinding:add group type fetching function, extend tests Change-Id: I754349ab5b6a8125ccc373210fc073dd71583c6f Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-29 15:19:36 +00:00
QQmlJSMetaPropertyBinding::NumberLiteral);
QMultiHash<QString, QQmlJSMetaPropertyBinding> bindingsOfBaseType;
getBindingsWithinGroup(&bindingsOfBaseType, 1);
QCOMPARE(bindingsOfBaseType.size(), 1);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(value(bindingsOfBaseType, u"top"_s).bindingType(), QQmlJSMetaPropertyBinding::Script);
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
}
QmlCompiler: Allow retrieval of descriptive name from invalid types Apparently we do that somewhere. It should not just crash. Pick-to: 6.2 6.3 Task-number: QTBUG-102147 Change-Id: Id612e0543d8794aa4f334a899b117142b7a8cd38 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-06 09:52:25 +00:00
void tst_qqmljsscope::descriptiveNameOfNull()
{
QQmlJSRegisterContent nullContent;
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(nullContent.descriptiveName(), u"(invalid type)"_s);
QmlCompiler: Allow retrieval of descriptive name from invalid types Apparently we do that somewhere. It should not just crash. Pick-to: 6.2 6.3 Task-number: QTBUG-102147 Change-Id: Id612e0543d8794aa4f334a899b117142b7a8cd38 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-06 09:52:25 +00:00
QQmlJSScope::Ptr stored = QQmlJSScope::create();
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
stored->setInternalName(u"bar"_s);
QmlCompiler: Allow retrieval of descriptive name from invalid types Apparently we do that somewhere. It should not just crash. Pick-to: 6.2 6.3 Task-number: QTBUG-102147 Change-Id: Id612e0543d8794aa4f334a899b117142b7a8cd38 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-06 09:52:25 +00:00
QQmlJSMetaProperty property;
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
property.setPropertyName(u"foo"_s);
property.setTypeName(u"baz"_s);
QmlCompiler: Allow retrieval of descriptive name from invalid types Apparently we do that somewhere. It should not just crash. Pick-to: 6.2 6.3 Task-number: QTBUG-102147 Change-Id: Id612e0543d8794aa4f334a899b117142b7a8cd38 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-06 09:52:25 +00:00
QQmlJSRegisterContent unscoped = QQmlJSRegisterContent::create(
stored, property, QQmlJSRegisterContent::ScopeProperty, QQmlJSScope::ConstPtr());
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(unscoped.descriptiveName(), u"bar of (invalid type)::foo with type baz"_s);
QmlCompiler: Allow retrieval of descriptive name from invalid types Apparently we do that somewhere. It should not just crash. Pick-to: 6.2 6.3 Task-number: QTBUG-102147 Change-Id: Id612e0543d8794aa4f334a899b117142b7a8cd38 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-06 09:52:25 +00:00
}
tst_qqmljsscope: Cover a more sophisticated group property case Document (via test) what happens when we re-assign a group property in the derived scope Introduce a QML test module along the way used within the test As a drive by, add all QML test files to TESTDATA Change-Id: Id4c3e20e45b8e0f3757840c87e0285f8516319a8 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-03-30 10:50:46 +00:00
void tst_qqmljsscope::groupedPropertiesConsistency()
{
{
QQmlEngine engine;
QQmlComponent component(&engine);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
component.loadUrl(testFileUrl(u"groupPropertiesConsistency.qml"_s));
tst_qqmljsscope: Cover a more sophisticated group property case Document (via test) what happens when we re-assign a group property in the derived scope Introduce a QML test module along the way used within the test As a drive by, add all QML test files to TESTDATA Change-Id: Id4c3e20e45b8e0f3757840c87e0285f8516319a8 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-03-30 10:50:46 +00:00
QVERIFY2(component.isReady(), qPrintable(component.errorString()));
QScopedPointer<QObject> root(component.create());
QVERIFY2(root, qPrintable(component.errorString()));
QFont font = qvariant_cast<QFont>(root->property("font"));
QCOMPARE(font.pixelSize(), 22);
}
{
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QQmlJSScope::ConstPtr root = run(u"groupPropertiesConsistency.qml"_s);
tst_qqmljsscope: Cover a more sophisticated group property case Document (via test) what happens when we re-assign a group property in the derived scope Introduce a QML test module along the way used within the test As a drive by, add all QML test files to TESTDATA Change-Id: Id4c3e20e45b8e0f3757840c87e0285f8516319a8 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-03-30 10:50:46 +00:00
QVERIFY(root);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
const auto fontBindings = root->propertyBindings(u"font"_s);
tst_qqmljsscope: Cover a more sophisticated group property case Document (via test) what happens when we re-assign a group property in the derived scope Introduce a QML test module along the way used within the test As a drive by, add all QML test files to TESTDATA Change-Id: Id4c3e20e45b8e0f3757840c87e0285f8516319a8 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-03-30 10:50:46 +00:00
QCOMPARE(fontBindings.size(), 2);
// The binding order in QQmlJSScope case is "reversed": first come
// bindings on the leaf type, followed by the bindings on the base type
QCOMPARE(fontBindings[0].bindingType(), QQmlJSMetaPropertyBinding::GroupProperty);
QCOMPARE(fontBindings[1].bindingType(), QQmlJSMetaPropertyBinding::Script);
}
}
qmlcompiler: Create group binding in group property syntax case Cover the following case of binding on a group property: Type { group { foo: 42 } } Task-number: QTBUG-100168 Change-Id: I0147c74dffb649907457d5f17a2ab29473101a6d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 12:15:32 +00:00
void tst_qqmljsscope::groupedPropertySyntax()
{
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QQmlJSScope::ConstPtr root = run(u"groupPropertySyntax.qml"_s);
qmlcompiler: Create group binding in group property syntax case Cover the following case of binding on a group property: Type { group { foo: 42 } } Task-number: QTBUG-100168 Change-Id: I0147c74dffb649907457d5f17a2ab29473101a6d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 12:15:32 +00:00
QVERIFY(root);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
const auto fontBindings = root->propertyBindings(u"font"_s);
qmlcompiler: Create group binding in group property syntax case Cover the following case of binding on a group property: Type { group { foo: 42 } } Task-number: QTBUG-100168 Change-Id: I0147c74dffb649907457d5f17a2ab29473101a6d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 12:15:32 +00:00
QCOMPARE(fontBindings.size(), 1);
// The binding order in QQmlJSScope case is "reversed": first come
// bindings on the leaf type, followed by the bindings on the base type
QCOMPARE(fontBindings[0].bindingType(), QQmlJSMetaPropertyBinding::GroupProperty);
auto fontScope = fontBindings[0].groupType();
QVERIFY(fontScope);
Inherit base type access semantics in QQmlJSScopes Group scopes may be value types so they require access semantics different from a default value Ordinary scopes and attached scopes seem unaffected, only groups are thus covered with an extra logic Change-Id: Ia9012548a602ca7ca07296491d27a295f4455f91 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-25 14:24:24 +00:00
QCOMPARE(fontScope->accessSemantics(), QQmlJSScope::AccessSemantics::Value);
qmlcompiler: Create group binding in group property syntax case Cover the following case of binding on a group property: Type { group { foo: 42 } } Task-number: QTBUG-100168 Change-Id: I0147c74dffb649907457d5f17a2ab29473101a6d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 12:15:32 +00:00
auto subbindings = fontScope->ownPropertyBindings();
QCOMPARE(subbindings.size(), 2);
const auto value = [](const QMultiHash<QString, QQmlJSMetaPropertyBinding> &bindings,
const QString &key) {
return bindings.value(key, QQmlJSMetaPropertyBinding(QQmlJS::SourceLocation {}));
};
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(value(subbindings, u"pixelSize"_s).bindingType(),
qmlcompiler: Create group binding in group property syntax case Cover the following case of binding on a group property: Type { group { foo: 42 } } Task-number: QTBUG-100168 Change-Id: I0147c74dffb649907457d5f17a2ab29473101a6d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 12:15:32 +00:00
QQmlJSMetaPropertyBinding::NumberLiteral);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(value(subbindings, u"bold"_s).bindingType(), QQmlJSMetaPropertyBinding::BoolLiteral);
qmlcompiler: Create group binding in group property syntax case Cover the following case of binding on a group property: Type { group { foo: 42 } } Task-number: QTBUG-100168 Change-Id: I0147c74dffb649907457d5f17a2ab29473101a6d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 12:15:32 +00:00
}
qmlcompiler: Support attached property bindings Extend group property binding creation with attached properties case As a drive by, add extra attached property tests for QML and qmltc, covering the case where an attaching type exists in both base and derived types Task-number: QTBUG-102082 Change-Id: I6c0d2b941da72d6dab7fc05a4f7b2a7875423ef0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 15:16:11 +00:00
void tst_qqmljsscope::attachedProperties()
{
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QQmlJSScope::ConstPtr root = run(u"attachedProperties.qml"_s);
qmlcompiler: Support attached property bindings Extend group property binding creation with attached properties case As a drive by, add extra attached property tests for QML and qmltc, covering the case where an attaching type exists in both base and derived types Task-number: QTBUG-102082 Change-Id: I6c0d2b941da72d6dab7fc05a4f7b2a7875423ef0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 15:16:11 +00:00
QVERIFY(root);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
const auto keysBindings = root->propertyBindings(u"Keys"_s);
qmlcompiler: Support attached property bindings Extend group property binding creation with attached properties case As a drive by, add extra attached property tests for QML and qmltc, covering the case where an attaching type exists in both base and derived types Task-number: QTBUG-102082 Change-Id: I6c0d2b941da72d6dab7fc05a4f7b2a7875423ef0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 15:16:11 +00:00
QVERIFY(!keysBindings.isEmpty());
QCOMPARE(keysBindings.size(), 2); // from type itself and from the base type
const auto getBindingsWithinAttached =
[&](QMultiHash<QString, QQmlJSMetaPropertyBinding> *bindings, qsizetype index) -> void {
const auto &binding = keysBindings[index];
QCOMPARE(binding.bindingType(), QQmlJSMetaPropertyBinding::AttachedProperty);
auto keysScope = binding.attachingType();
QVERIFY(keysScope);
Inherit base type access semantics in QQmlJSScopes Group scopes may be value types so they require access semantics different from a default value Ordinary scopes and attached scopes seem unaffected, only groups are thus covered with an extra logic Change-Id: Ia9012548a602ca7ca07296491d27a295f4455f91 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-25 14:24:24 +00:00
QCOMPARE(keysScope->accessSemantics(), QQmlJSScope::AccessSemantics::Reference);
qmlcompiler: Support attached property bindings Extend group property binding creation with attached properties case As a drive by, add extra attached property tests for QML and qmltc, covering the case where an attaching type exists in both base and derived types Task-number: QTBUG-102082 Change-Id: I6c0d2b941da72d6dab7fc05a4f7b2a7875423ef0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 15:16:11 +00:00
*bindings = keysScope->ownPropertyBindings();
};
const auto value = [](const QMultiHash<QString, QQmlJSMetaPropertyBinding> &bindings,
const QString &key) {
return bindings.value(key, QQmlJSMetaPropertyBinding(QQmlJS::SourceLocation {}));
};
QMultiHash<QString, QQmlJSMetaPropertyBinding> bindingsOfType;
getBindingsWithinAttached(&bindingsOfType, 0);
QCOMPARE(bindingsOfType.size(), 2);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(value(bindingsOfType, u"enabled"_s).bindingType(),
qmlcompiler: Support attached property bindings Extend group property binding creation with attached properties case As a drive by, add extra attached property tests for QML and qmltc, covering the case where an attaching type exists in both base and derived types Task-number: QTBUG-102082 Change-Id: I6c0d2b941da72d6dab7fc05a4f7b2a7875423ef0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 15:16:11 +00:00
QQmlJSMetaPropertyBinding::BoolLiteral);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(value(bindingsOfType, u"forwardTo"_s).bindingType(),
qmlcompiler: Support attached property bindings Extend group property binding creation with attached properties case As a drive by, add extra attached property tests for QML and qmltc, covering the case where an attaching type exists in both base and derived types Task-number: QTBUG-102082 Change-Id: I6c0d2b941da72d6dab7fc05a4f7b2a7875423ef0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 15:16:11 +00:00
QQmlJSMetaPropertyBinding::Script);
QMultiHash<QString, QQmlJSMetaPropertyBinding> bindingsOfBaseType;
getBindingsWithinAttached(&bindingsOfBaseType, 1);
QCOMPARE(bindingsOfBaseType.size(), 1);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QCOMPARE(value(bindingsOfBaseType, u"priority"_s).bindingType(),
qmlcompiler: Support attached property bindings Extend group property binding creation with attached properties case As a drive by, add extra attached property tests for QML and qmltc, covering the case where an attaching type exists in both base and derived types Task-number: QTBUG-102082 Change-Id: I6c0d2b941da72d6dab7fc05a4f7b2a7875423ef0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-30 15:16:11 +00:00
QQmlJSMetaPropertyBinding::Script);
}
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
inline QString getScopeName(const QQmlJSScope::ConstPtr &scope)
{
Q_ASSERT(scope);
QQmlJSScope::ScopeType type = scope->scopeType();
if (type == QQmlJSScope::GroupedPropertyScope || type == QQmlJSScope::AttachedPropertyScope)
return scope->internalName();
return scope->baseTypeName();
}
QmlCompiler: Fix script indices calculation The logic is misbehaving on multiple occasions. For instance, same-named signal handlers in different scopes and script bindings inside array scopes were wrongly handled. Fix that by revising the mechanism of inner function computation As a drive by, fix parseLiteralOrScriptBinding() to distinguish translation bindings from script bindings (they are vitally different now) Extend the script calculation test in tst_qqmljsscope to cover the findings Pick-to: 6.4 Change-Id: Ic4cf0a4539f0d714a416b61f4635eb6494e89922 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-01 14:47:37 +00:00
struct FunctionOrExpressionIdentifier
{
QString name;
QQmlJS::SourceLocation loc = QQmlJS::SourceLocation {}; // source location of owning scope
int index = -1; // relative or absolute script index
FunctionOrExpressionIdentifier() = default;
FunctionOrExpressionIdentifier(const QString &name, const QQmlJS::SourceLocation &l, int i)
: name(name), loc(l), index(i)
{
}
FunctionOrExpressionIdentifier(const QString &name, const QV4::CompiledData::Location &l, int i)
: name(name), loc(QQmlJS::SourceLocation { 0, 0, l.line(), l.column() }), index(i)
{
}
friend bool operator<(const FunctionOrExpressionIdentifier &x,
const FunctionOrExpressionIdentifier &y)
{
// source location is taken from the owner scope so would be non-unique,
// while name must be unique within that scope. so: if source locations
// match, compare by name
if (x.loc == y.loc)
return x.name < y.name;
// otherwise, compare by start line first, if they match, then by column
if (x.loc.startLine == y.loc.startLine)
return x.loc.startColumn < y.loc.startColumn;
return x.loc.startLine < y.loc.startLine;
}
friend bool operator==(const FunctionOrExpressionIdentifier &x,
const FunctionOrExpressionIdentifier &y)
{
// equal-compare by name and index
return x.index == y.index && x.name == y.name;
}
friend bool operator!=(const FunctionOrExpressionIdentifier &x,
const FunctionOrExpressionIdentifier &y)
{
return !(x == y);
}
friend QDebug &operator<<(QDebug &stream, const FunctionOrExpressionIdentifier &x)
{
const QString dump = u"(%1, %2, loc %3:%4)"_s.arg(x.name, QString::number(x.index),
QString::number(x.loc.startLine),
QString::number(x.loc.startColumn));
stream << dump;
return stream.maybeSpace();
}
};
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
void tst_qqmljsscope::scriptIndices()
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
{
{
QQmlEngine engine;
QQmlComponent component(&engine);
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
component.loadUrl(testFileUrl(u"functionAndBindingIndices.qml"_s));
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
QVERIFY2(component.isReady(), qPrintable(component.errorString()));
QScopedPointer<QObject> root(component.create());
QVERIFY2(root, qPrintable(component.errorString()));
}
QmlIR::Document document(false); // we need QmlIR information here
Replace uses of deprecated _qs with _s/QStringLiteral Task-number: QTBUG-101408 Change-Id: Ic925751b73f52d8fa5add5cacc52d6dd6ea2dc27 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-21 09:21:18 +00:00
QQmlJSScope::ConstPtr root = run(u"functionAndBindingIndices.qml"_s, &document);
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
QVERIFY(root);
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
QVERIFY(document.javaScriptCompilationUnit.unitData());
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
// compare QQmlJSScope and QmlIR:
// {property, function}Name and relative (per-object) function table index
QmlCompiler: Fix script indices calculation The logic is misbehaving on multiple occasions. For instance, same-named signal handlers in different scopes and script bindings inside array scopes were wrongly handled. Fix that by revising the mechanism of inner function computation As a drive by, fix parseLiteralOrScriptBinding() to distinguish translation bindings from script bindings (they are vitally different now) Extend the script calculation test in tst_qqmljsscope to cover the findings Pick-to: 6.4 Change-Id: Ic4cf0a4539f0d714a416b61f4635eb6494e89922 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-01 14:47:37 +00:00
QList<FunctionOrExpressionIdentifier> orderedJSScopeExpressionsRelative;
QList<FunctionOrExpressionIdentifier> orderedQmlIrExpressionsRelative;
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
// {property, function}Name and absolute (per-document) function table index
QmlCompiler: Fix script indices calculation The logic is misbehaving on multiple occasions. For instance, same-named signal handlers in different scopes and script bindings inside array scopes were wrongly handled. Fix that by revising the mechanism of inner function computation As a drive by, fix parseLiteralOrScriptBinding() to distinguish translation bindings from script bindings (they are vitally different now) Extend the script calculation test in tst_qqmljsscope to cover the findings Pick-to: 6.4 Change-Id: Ic4cf0a4539f0d714a416b61f4635eb6494e89922 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-01 14:47:37 +00:00
QList<FunctionOrExpressionIdentifier> orderedJSScopeExpressionsAbsolute;
QList<FunctionOrExpressionIdentifier> orderedQmlIrExpressionsAbsolute;
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
const auto populateQQmlJSScopeArrays =
[&](const QQmlJSScope::ConstPtr &scope, const QString &name,
QQmlJSMetaMethod::RelativeFunctionIndex relativeIndex) {
QmlCompiler: Fix script indices calculation The logic is misbehaving on multiple occasions. For instance, same-named signal handlers in different scopes and script bindings inside array scopes were wrongly handled. Fix that by revising the mechanism of inner function computation As a drive by, fix parseLiteralOrScriptBinding() to distinguish translation bindings from script bindings (they are vitally different now) Extend the script calculation test in tst_qqmljsscope to cover the findings Pick-to: 6.4 Change-Id: Ic4cf0a4539f0d714a416b61f4635eb6494e89922 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-01 14:47:37 +00:00
orderedJSScopeExpressionsRelative.emplaceBack(name, scope->sourceLocation(),
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
static_cast<int>(relativeIndex));
auto absoluteIndex = scope->ownRuntimeFunctionIndex(relativeIndex);
QmlCompiler: Fix script indices calculation The logic is misbehaving on multiple occasions. For instance, same-named signal handlers in different scopes and script bindings inside array scopes were wrongly handled. Fix that by revising the mechanism of inner function computation As a drive by, fix parseLiteralOrScriptBinding() to distinguish translation bindings from script bindings (they are vitally different now) Extend the script calculation test in tst_qqmljsscope to cover the findings Pick-to: 6.4 Change-Id: Ic4cf0a4539f0d714a416b61f4635eb6494e89922 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-01 14:47:37 +00:00
orderedJSScopeExpressionsAbsolute.emplaceBack(name, scope->sourceLocation(),
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
static_cast<int>(absoluteIndex));
};
const auto populateQmlIRArrays = [&](const QmlIR::Object *irObject, const QString &name,
int relative) {
QmlCompiler: Fix script indices calculation The logic is misbehaving on multiple occasions. For instance, same-named signal handlers in different scopes and script bindings inside array scopes were wrongly handled. Fix that by revising the mechanism of inner function computation As a drive by, fix parseLiteralOrScriptBinding() to distinguish translation bindings from script bindings (they are vitally different now) Extend the script calculation test in tst_qqmljsscope to cover the findings Pick-to: 6.4 Change-Id: Ic4cf0a4539f0d714a416b61f4635eb6494e89922 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-01 14:47:37 +00:00
orderedQmlIrExpressionsRelative.emplaceBack(name, irObject->location, relative);
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
auto absolute = irObject->runtimeFunctionIndices.at(relative);
QmlCompiler: Fix script indices calculation The logic is misbehaving on multiple occasions. For instance, same-named signal handlers in different scopes and script bindings inside array scopes were wrongly handled. Fix that by revising the mechanism of inner function computation As a drive by, fix parseLiteralOrScriptBinding() to distinguish translation bindings from script bindings (they are vitally different now) Extend the script calculation test in tst_qqmljsscope to cover the findings Pick-to: 6.4 Change-Id: Ic4cf0a4539f0d714a416b61f4635eb6494e89922 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-01 14:47:37 +00:00
orderedQmlIrExpressionsAbsolute.emplaceBack(name, irObject->location, absolute);
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
};
const auto suitableScope = [](const QQmlJSScope::ConstPtr &scope) {
const auto type = scope->scopeType();
return type == QQmlJSScope::QMLScope || type == QQmlJSScope::GroupedPropertyScope
|| type == QQmlJSScope::AttachedPropertyScope;
};
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
QList<QQmlJSScope::ConstPtr> queue;
queue.push_back(root);
while (!queue.isEmpty()) {
auto current = queue.front();
queue.pop_front();
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
if (suitableScope(current)) {
const auto methods = current->ownMethods();
for (const auto &method : methods) {
if (method.methodType() == QQmlJSMetaMethod::Signal)
continue;
QString name = method.methodName();
auto relativeIndex = method.jsFunctionIndex();
QVERIFY2(static_cast<int>(relativeIndex) >= 0,
qPrintable(QStringLiteral("Method %1 from %2 has no index")
.arg(name, getScopeName(current))));
populateQQmlJSScopeArrays(current, name, relativeIndex);
}
const auto bindings = current->ownPropertyBindings();
for (const auto &binding : bindings) {
if (binding.bindingType() != QQmlJSMetaPropertyBinding::Script)
continue;
QString name = binding.propertyName();
auto relativeIndex = binding.scriptIndex();
QVERIFY2(static_cast<int>(relativeIndex) >= 0,
qPrintable(QStringLiteral("Binding on property %1 from %2 has no index")
.arg(name, getScopeName(current))));
populateQQmlJSScopeArrays(current, name, relativeIndex);
}
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
}
const auto children = current->childScopes();
for (const auto &c : children)
queue.push_back(c);
}
for (const QmlIR::Object *irObject : qAsConst(document.objects)) {
const QString objectName = document.stringAt(irObject->inheritedTypeNameIndex);
for (auto it = irObject->functionsBegin(); it != irObject->functionsEnd(); ++it) {
QString name = document.stringAt(it->nameIndex);
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
populateQmlIRArrays(irObject, name, it->index);
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
}
for (auto it = irObject->bindingsBegin(); it != irObject->bindingsEnd(); ++it) {
QML: Port QV4::CompiledData::Binding to new special integer bitfield Pick-to: 5.15 6.2 6.3 Task-number: QTBUG-99545 Change-Id: I9f8bc5fa45c61f77ee95b055a3d8de001da8f8c5 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-05-04 13:26:30 +00:00
if (it->type() != QmlIR::Binding::Type_Script)
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
continue;
QString name = document.stringAt(it->propertyNameIndex);
int index = it->value.compiledScriptIndex;
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
populateQmlIRArrays(irObject, name, index);
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
}
}
QmlCompiler: Fix script indices calculation The logic is misbehaving on multiple occasions. For instance, same-named signal handlers in different scopes and script bindings inside array scopes were wrongly handled. Fix that by revising the mechanism of inner function computation As a drive by, fix parseLiteralOrScriptBinding() to distinguish translation bindings from script bindings (they are vitally different now) Extend the script calculation test in tst_qqmljsscope to cover the findings Pick-to: 6.4 Change-Id: Ic4cf0a4539f0d714a416b61f4635eb6494e89922 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-01 14:47:37 +00:00
std::sort(orderedJSScopeExpressionsRelative.begin(), orderedJSScopeExpressionsRelative.end());
std::sort(orderedQmlIrExpressionsRelative.begin(), orderedQmlIrExpressionsRelative.end());
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
QmlCompiler: Fix script indices calculation The logic is misbehaving on multiple occasions. For instance, same-named signal handlers in different scopes and script bindings inside array scopes were wrongly handled. Fix that by revising the mechanism of inner function computation As a drive by, fix parseLiteralOrScriptBinding() to distinguish translation bindings from script bindings (they are vitally different now) Extend the script calculation test in tst_qqmljsscope to cover the findings Pick-to: 6.4 Change-Id: Ic4cf0a4539f0d714a416b61f4635eb6494e89922 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-01 14:47:37 +00:00
std::sort(orderedJSScopeExpressionsAbsolute.begin(), orderedJSScopeExpressionsAbsolute.end());
std::sort(orderedQmlIrExpressionsAbsolute.begin(), orderedQmlIrExpressionsAbsolute.end());
qmlcompiler: Add absolute runtime function indices We can transition to absolute indices (within the compilation unit) from the relative indices we already have in each method and script binding. Together with absolute indices, we also need to acknowledge nested closures that some AST elements might have and so also store nested runtime function indices along with the absolute ones Absolute runtime function indices (and the nested ones) map to the indices we store and use within the compilation unit at run time, which are used to dispatch to correct JavaScript call during e.g. binding evaluation - see QQmlEnginePrivate::executeRuntimeFunction() Change-Id: Ieec58fbc36563511bd9763e358cda46c67757fa9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-06 07:56:17 +00:00
QCOMPARE(orderedJSScopeExpressionsRelative, orderedQmlIrExpressionsRelative);
QCOMPARE(orderedJSScopeExpressionsAbsolute, orderedQmlIrExpressionsAbsolute);
qmlcompiler: Add relative index for scripts and JS functions Store relative (to scope) index for every Script binding and JavaScript function into the corresponding data structure within QQmlJSScope. We need this at a later phase in qmltc when code generating JavaScript calls into the engine For now, ignore the logic that converts the relative indices stored into the indices pointing to the runtime function table While testing the addition, observe missing cases where we do not record bindings as such and fix that Change-Id: I85030b7937c97f83183f88ae242af3a5f223443c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-31 15:29:24 +00:00
}
Fix extension lookup in QQmlJSScope Do not go over extension's base types since this is not how the engine logic work. Instead, only assess the direct extension type when traversing the base type hierarchy. The special cases are value types which still need base type extension traversal (e.g. due to Number and NumberPrototype extensions on primitives) and QObject type itself (we expect to see ObjectPrototype properties / methods of it) Pick-to: 6.3 6.2 Change-Id: I92ba979202b33f16e1a7b948d4f1e79df37f2669 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-03 15:08:37 +00:00
void tst_qqmljsscope::extensions()
{
QQmlJSScope::ConstPtr root = run(u"extensions.qml"_s);
QVERIFY(root);
QVERIFY(root->isFullyResolved());
const auto childScopes = root->childScopes();
Distinguish extensions from extension namespaces in QmlCompiler library QML_{NAMESPACE_}EXTENDED and QML_EXTENDED_NAMESPACE are supposed to behave differently when it comes to visibility of properties, methods, etc. Thus, make it so by actually using different class infos and updating QQmlJSScope. Use a HasExtensionNamespace flag to differentiate between extension and extension namespace (whenever one of them is set) Update the internal search routine that traverses the base types and extensions of the given scope Change-Id: Ifafbb22f831f5b128e431a3e65c514ffdf65eb73 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-06 12:48:22 +00:00
QCOMPARE(childScopes.size(), 5);
Fix extension lookup in QQmlJSScope Do not go over extension's base types since this is not how the engine logic work. Instead, only assess the direct extension type when traversing the base type hierarchy. The special cases are value types which still need base type extension traversal (e.g. due to Number and NumberPrototype extensions on primitives) and QObject type itself (we expect to see ObjectPrototype properties / methods of it) Pick-to: 6.3 6.2 Change-Id: I92ba979202b33f16e1a7b948d4f1e79df37f2669 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-03 15:08:37 +00:00
QCOMPARE(childScopes[0]->baseTypeName(), u"Extended"_s);
QCOMPARE(childScopes[1]->baseTypeName(), u"ExtendedIndirect"_s);
QCOMPARE(childScopes[2]->baseTypeName(), u"ExtendedTwice"_s);
Distinguish extensions from extension namespaces in QmlCompiler library QML_{NAMESPACE_}EXTENDED and QML_EXTENDED_NAMESPACE are supposed to behave differently when it comes to visibility of properties, methods, etc. Thus, make it so by actually using different class infos and updating QQmlJSScope. Use a HasExtensionNamespace flag to differentiate between extension and extension namespace (whenever one of them is set) Update the internal search routine that traverses the base types and extensions of the given scope Change-Id: Ifafbb22f831f5b128e431a3e65c514ffdf65eb73 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-06 12:48:22 +00:00
QCOMPARE(childScopes[3]->baseTypeName(), u"NamespaceExtended"_s);
QCOMPARE(childScopes[4]->baseTypeName(), u"NonNamespaceExtended"_s);
Fix extension lookup in QQmlJSScope Do not go over extension's base types since this is not how the engine logic work. Instead, only assess the direct extension type when traversing the base type hierarchy. The special cases are value types which still need base type extension traversal (e.g. due to Number and NumberPrototype extensions on primitives) and QObject type itself (we expect to see ObjectPrototype properties / methods of it) Pick-to: 6.3 6.2 Change-Id: I92ba979202b33f16e1a7b948d4f1e79df37f2669 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-03 15:08:37 +00:00
QVERIFY(childScopes[0]->isFullyResolved());
QVERIFY(childScopes[1]->isFullyResolved());
QVERIFY(childScopes[2]->isFullyResolved());
Distinguish extensions from extension namespaces in QmlCompiler library QML_{NAMESPACE_}EXTENDED and QML_EXTENDED_NAMESPACE are supposed to behave differently when it comes to visibility of properties, methods, etc. Thus, make it so by actually using different class infos and updating QQmlJSScope. Use a HasExtensionNamespace flag to differentiate between extension and extension namespace (whenever one of them is set) Update the internal search routine that traverses the base types and extensions of the given scope Change-Id: Ifafbb22f831f5b128e431a3e65c514ffdf65eb73 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-06 12:48:22 +00:00
QVERIFY(childScopes[3]->isFullyResolved());
QVERIFY(childScopes[4]->isFullyResolved());
Fix extension lookup in QQmlJSScope Do not go over extension's base types since this is not how the engine logic work. Instead, only assess the direct extension type when traversing the base type hierarchy. The special cases are value types which still need base type extension traversal (e.g. due to Number and NumberPrototype extensions on primitives) and QObject type itself (we expect to see ObjectPrototype properties / methods of it) Pick-to: 6.3 6.2 Change-Id: I92ba979202b33f16e1a7b948d4f1e79df37f2669 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-03 15:08:37 +00:00
QCOMPARE(childScopes[0]->property(u"count"_s).typeName(), u"int"_s);
QCOMPARE(childScopes[1]->property(u"count"_s).typeName(), u"double"_s);
QCOMPARE(childScopes[2]->property(u"count"_s).typeName(), u"int"_s);
QCOMPARE(childScopes[2]->property(u"str"_s).typeName(), u"QString"_s);
Distinguish extensions from extension namespaces in QmlCompiler library QML_{NAMESPACE_}EXTENDED and QML_EXTENDED_NAMESPACE are supposed to behave differently when it comes to visibility of properties, methods, etc. Thus, make it so by actually using different class infos and updating QQmlJSScope. Use a HasExtensionNamespace flag to differentiate between extension and extension namespace (whenever one of them is set) Update the internal search routine that traverses the base types and extensions of the given scope Change-Id: Ifafbb22f831f5b128e431a3e65c514ffdf65eb73 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-06 12:48:22 +00:00
QVERIFY(!childScopes[3]->hasProperty(u"count"_s));
QVERIFY(!childScopes[3]->property(u"count"_s).isValid());
QVERIFY(!childScopes[3]->hasProperty(u"p"_s));
QVERIFY(!childScopes[3]->property(u"p"_s).isValid());
QVERIFY(!childScopes[3]->hasMethod(u"someMethod"_s));
QVERIFY(childScopes[3]->hasEnumeration(u"ExtensionEnum"_s));
QVERIFY(childScopes[3]->hasEnumerationKey(u"Value1"_s));
QVERIFY(childScopes[3]->enumeration(u"ExtensionEnum"_s).isValid());
QCOMPARE(childScopes[3]->defaultPropertyName(), u"objectName"_s);
QCOMPARE(childScopes[3]->parentPropertyName(), u"p"_s);
QVERIFY(!childScopes[3]->hasInterface(u"QQmlParserStatus"_s));
QCOMPARE(childScopes[3]->attachedTypeName(), QString());
QVERIFY(!childScopes[3]->attachedType());
QVERIFY(!childScopes[3]->extensionIsNamespace());
QVERIFY(childScopes[3]->baseType()->extensionIsNamespace());
QVERIFY(childScopes[4]->hasProperty(u"count"_s));
QVERIFY(childScopes[4]->property(u"count"_s).isValid());
QVERIFY(childScopes[4]->hasProperty(u"p"_s));
QVERIFY(childScopes[4]->property(u"p"_s).isValid());
QVERIFY(childScopes[4]->hasMethod(u"someMethod"_s));
QVERIFY(childScopes[4]->hasEnumeration(u"ExtensionEnum"_s));
QVERIFY(childScopes[4]->hasEnumerationKey(u"Value1"_s));
QVERIFY(childScopes[4]->enumeration(u"ExtensionEnum"_s).isValid());
QCOMPARE(childScopes[4]->defaultPropertyName(), u"objectName"_s);
QCOMPARE(childScopes[4]->parentPropertyName(), u"p"_s);
QVERIFY(!childScopes[4]->hasInterface(u"QQmlParserStatus"_s));
QCOMPARE(childScopes[4]->attachedTypeName(), QString());
QVERIFY(!childScopes[4]->attachedType());
auto [owner, ownerKind] = QQmlJSScope::ownerOfProperty(childScopes[4], u"count"_s);
QVERIFY(owner);
QCOMPARE(ownerKind, QQmlJSScope::ExtensionType);
QCOMPARE(owner, childScopes[4]->baseType()->extensionType().scope);
Fix extension lookup in QQmlJSScope Do not go over extension's base types since this is not how the engine logic work. Instead, only assess the direct extension type when traversing the base type hierarchy. The special cases are value types which still need base type extension traversal (e.g. due to Number and NumberPrototype extensions on primitives) and QObject type itself (we expect to see ObjectPrototype properties / methods of it) Pick-to: 6.3 6.2 Change-Id: I92ba979202b33f16e1a7b948d4f1e79df37f2669 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-03 15:08:37 +00:00
}
qqmljsimportvisitor: Fix assert being hit on empty block bindings We previously hit an assert / crashed if we saw an empty script binding. Fixes: QTBUG-103707 Change-Id: I117d984a7d315ecf860d2ada5568637d154ae083 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-05-19 13:41:24 +00:00
void tst_qqmljsscope::emptyBlockBinding()
{
QQmlJSScope::ConstPtr root = run(u"emptyBlockBinding.qml"_s);
QVERIFY(root);
QVERIFY(root->hasOwnPropertyBindings(u"x"_s));
QVERIFY(root->hasOwnPropertyBindings(u"y"_s));
}
qmlcompiler: Add qualified name to QQmlJSScope Added moduleName and qualifiedName to QQmlJSScope. Those properties are written in the scopes after they were loaded by readQmlDir. Fixes: QTBUG-103299 Change-Id: I3b2c68c43c3bf0ac6cf801b0e54cf4b412b4d4e5 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-05-19 08:35:20 +00:00
void tst_qqmljsscope::qualifiedName()
{
QQmlJSScope::ConstPtr root = run(u"qualifiedName.qml"_s);
auto qualifiedNameOf = [](const QQmlJSScope::ConstPtr &ptr) {
return ptr->baseType()->qualifiedName();
};
QQmlJSScope::ConstPtr item = root;
// normal case
QCOMPARE(qualifiedNameOf(item), "QtQuick/Item 2.0-6.3");
QCOMPARE(item->childScopes().size(), 4);
QQmlJSScope::ConstPtr textInItem = item->childScopes()[0];
QQmlJSScope::ConstPtr nonQualifiedComponentInItem = item->childScopes()[1];
QQmlJSScope::ConstPtr qualifiedComponentInItem = item->childScopes()[2];
QQmlJSScope::ConstPtr componentInItem = item->childScopes()[3];
// qualified case
QCOMPARE(qualifiedNameOf(nonQualifiedComponentInItem), "QtQuick/TextEdit 2.0-6.3");
// qualified case
QCOMPARE(qualifiedNameOf(qualifiedComponentInItem), "QtQuick/TextEdit 2.0-6.3");
// normal case
QCOMPARE(qualifiedNameOf(textInItem), "QtQuick/Text 2.0-6.3");
// qualified import of builtin variable
QCOMPARE(qualifiedNameOf(componentInItem), "QML/Component 1.0");
QCOMPARE(componentInItem->baseType()->moduleName(), "QML");
QCOMPARE(componentInItem->childScopes().size(), 1);
QQmlJSScope::ConstPtr itemInComponent = componentInItem->childScopes()[0];
QCOMPARE(qualifiedNameOf(itemInComponent), "QtQuick/Item 2.0-6.3");
QCOMPARE(itemInComponent->childScopes().size(), 5);
QQmlJSScope::ConstPtr qualifiedImportTextInItemInComponent = itemInComponent->childScopes()[0];
QQmlJSScope::ConstPtr textInItemInComponent = itemInComponent->childScopes()[1];
QQmlJSScope::ConstPtr qualifiedImportTextInputInItemInComponent =
itemInComponent->childScopes()[2];
QQmlJSScope::ConstPtr indirectImportTimerInItemInComponent = itemInComponent->childScopes()[3];
QQmlJSScope::ConstPtr qualifiedImportTimerInItemInComponent = itemInComponent->childScopes()[4];
QCOMPARE(qualifiedNameOf(qualifiedImportTextInItemInComponent), "QtQuick/Text 2.0-6.3");
QCOMPARE(qualifiedNameOf(textInItemInComponent), "QtQuick/Text 2.0-6.3");
QCOMPARE(textInItemInComponent->baseType()->moduleName(), "QtQuick");
QCOMPARE(qualifiedImportTextInItemInComponent->baseType()->moduleName(), "QtQuick");
QCOMPARE(qualifiedNameOf(qualifiedImportTextInputInItemInComponent),
"QtQuick/TextInput 2.0-6.3");
QCOMPARE(qualifiedNameOf(indirectImportTimerInItemInComponent), "QtQml/Timer 2.0-6.0");
QCOMPARE(qualifiedNameOf(qualifiedImportTimerInItemInComponent), "QtQml/Timer 2.0-6.0");
QCOMPARE(indirectImportTimerInItemInComponent->baseType()->moduleName(), "QtQml");
QCOMPARE(qualifiedImportTimerInItemInComponent->baseType()->moduleName(), "QtQml");
}
Set bindings on QQmlJSScope after AST traversal We can get into situations when binding creation is problematic due to the relevant scopes being yet unresolved. In particular, this happens when processing attached/group properties script bindings Avoid having this situation by postponing the actual binding setting until after the relavant scopes are resolved (mainly, the binding owner). However, do relevant AST order dependent operations beforehand to avoid accidental errors This commit amends 25098b7a4fdb8920874a817956f659e6393548d2 Fixes: QTBUG-103897 Change-Id: I671955dbe321d03e5f1ab9891cc79dc0a936deda Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-05-25 13:18:56 +00:00
void tst_qqmljsscope::resolvedNonUniqueScopes()
{
QQmlJSScope::ConstPtr root = run(u"resolvedNonUniqueScope.qml"_s);
QVERIFY(root);
const auto value = [](const QMultiHash<QString, QQmlJSMetaPropertyBinding> &bindings,
const QString &key) {
return bindings.value(key, QQmlJSMetaPropertyBinding(QQmlJS::SourceLocation {}));
};
{
auto topLevelBindings = root->propertyBindings(u"Component"_s);
QCOMPARE(topLevelBindings.size(), 1);
QCOMPARE(topLevelBindings[0].bindingType(), QQmlJSMetaPropertyBinding::AttachedProperty);
auto componentScope = topLevelBindings[0].attachingType();
auto componentBindings = componentScope->ownPropertyBindings();
QCOMPARE(componentBindings.size(), 2);
auto onCompletedBinding = value(componentBindings, u"onCompleted"_s);
QVERIFY(onCompletedBinding.isValid());
QCOMPARE(onCompletedBinding.bindingType(), QQmlJSMetaPropertyBinding::Script);
QCOMPARE(onCompletedBinding.scriptKind(), QQmlJSMetaPropertyBinding::Script_SignalHandler);
auto onDestructionBinding = value(componentBindings, u"onDestruction"_s);
QVERIFY(onDestructionBinding.isValid());
QCOMPARE(onDestructionBinding.bindingType(), QQmlJSMetaPropertyBinding::Script);
QCOMPARE(onDestructionBinding.scriptKind(),
QQmlJSMetaPropertyBinding::Script_SignalHandler);
}
{
auto topLevelBindings = root->propertyBindings(u"p"_s);
QCOMPARE(topLevelBindings.size(), 1);
QCOMPARE(topLevelBindings[0].bindingType(), QQmlJSMetaPropertyBinding::GroupProperty);
auto pScope = topLevelBindings[0].groupType();
auto pBindings = pScope->ownPropertyBindings();
QCOMPARE(pBindings.size(), 1);
auto onXChangedBinding = value(pBindings, u"onXChanged"_s);
QVERIFY(onXChangedBinding.isValid());
QCOMPARE(onXChangedBinding.bindingType(), QQmlJSMetaPropertyBinding::Script);
QCOMPARE(onXChangedBinding.scriptKind(), QQmlJSMetaPropertyBinding::Script_SignalHandler);
}
}
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
QTEST_MAIN(tst_qqmljsscope)
#include "tst_qqmljsscope.moc"