qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtdeclarative/tools/qmltc/qmltccompiler.cpp

2050 lines
90 KiB
C++
Raw Permalink Normal View History

Use SPDX license identifiers Replace the current license disclaimer in files by a SPDX-License-Identifier. Files that have to be modified by hand are modified. License files are organized under LICENSES directory. Pick-to: 6.4 Task-number: QTBUG-67283 Change-Id: I63563bbeb6f60f89d2c99660400dca7fab78a294 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2022-05-13 13:12:05 +00:00
// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
Long live (dummy-for-now) qmltc! This is a stub commit that introduces qmltc as a binary We don't even attempt to generate any code here yet Task-number: QTBUG-84368 Change-Id: I98da17d839970a2561f501f3b9d6b1e1310e0e01 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-16 07:35:33 +00:00
#include "qmltccompiler.h"
qmltc: add cmake api and simplest file writer Also update tests to include the generated file. While the content is meaningless, it's good enough to check that the file is include-able at this stage Task-number: QTBUG-84368 Task-number: QTBUG-96040 Change-Id: I155826a52090c5b13d14be6330813dc5a27f28e5 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-17 15:01:56 +00:00
#include "qmltcoutputir.h"
#include "qmltccodewriter.h"
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
#include "qmltcpropertyutils.h"
qmltc: Learn to set QML context for objects Add the minimal test along the way. The most we can do at present is to check that root object's context is set correctly. Comprehensive tests require binding compilation The QQmlParserStatus::classBegin() shenanigans are skipped for now Change-Id: I5c28c8a4406753dcf0fc93d968800b4376ec6017 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-12 08:28:33 +00:00
#include "qmltccompilerpieces.h"
qmltc: Compile QML methods to C++ This also requires some changes to the output IR + couple things could also be fixed while at it Task-number: QTBUG-84368 Change-Id: Ie1535cbbe36cd874e9787ea91fe85b638326de20 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-01 15:18:30 +00:00
Explicitly include qloggingcategory.h Do not rely on QLoggingCategory being implicitly declared through other headers. Pick-to: 6.2 Change-Id: Ib6cda43f281d31a7127dd591be2540fb00a0a699 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2021-11-15 13:31:42 +00:00
#include <QtCore/qloggingcategory.h>
Replace signal name manipulations with QQmlSignalNames Remove custom implementations found in qqmljs* and use the static helper methods from qqmlsignalnames_p.h instead. This sometimes requires to move some code around to avoid bugs with property that do not have letters in their name. Add a warning in the JS implementation of the SignalSpy.qml that the used heuristic might fail on certain signal names. Add tests in in tst_qqmllanguage to see if the property change handlers work correctly for weird names. Change-Id: I4dc73c34df7f77f529511fa04ab5fcc5385b59fc Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-08-10 07:45:37 +00:00
#include <QtQml/private/qqmlsignalnames_p.h>
Unify common logic around QQmlJSScope and friends We have many things duplicated all over the place Pick-to: 6.3 Change-Id: If929a5d683153781f6db630312240bf9c24ec777 Reviewed-by: Fawzi Mohamed <fawzi.mohamed@qt.io>
2021-12-17 14:52:17 +00:00
#include <private/qqmljsutils_p.h>
Long live (dummy-for-now) qmltc! This is a stub commit that introduces qmltc as a binary We don't even attempt to generate any code here yet Task-number: QTBUG-84368 Change-Id: I98da17d839970a2561f501f3b9d6b1e1310e0e01 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-16 07:35:33 +00:00
qmltc: Compile QML enums into C++ Task-number: QTBUG-84368 Change-Id: Idf6c724496c807477ce0914ab0d32a80a9b90b5a Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 10:43:44 +00:00
#include <algorithm>
Long live (dummy-for-now) qmltc! This is a stub commit that introduces qmltc as a binary We don't even attempt to generate any code here yet Task-number: QTBUG-84368 Change-Id: I98da17d839970a2561f501f3b9d6b1e1310e0e01 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-16 07:35:33 +00:00
QT_BEGIN_NAMESPACE
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;
Support value type lists in qmltc Generate list of values in qmltc when possible, by using QList<T> instead of QQmlListProperty<T>, e.g., when T is an int or a QColor.. Fixes: QTBUG-100313 Change-Id: Ifd84cbb550437854fb156a295435240cef446e61 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-06-29 15:21:49 +00:00
bool qIsReferenceTypeList(const QQmlJSMetaProperty &p)
{
QmlCompiler: Allow lists as arguments to methods Since lists are allowed as property types, you should be able to pass them as arguments to methods, too. For now we only handle QML-defined methods, implemented by adding JavaScript functions to your QML elements. The usual type coercion rules apply if you pass JavaScript arrays to such methods. That is, it usually works. We now resolve properties with the "list" flag to their actual types (QQmlListProperty or QList) already when populating the QQmlJSScope, and store the list types as members of QQmlJSScope rather than as a special map in QQmlJSTypeResolver. This allows us to do the same to lists passed as arguments and simplifies some of the type analysis. Fixes: QTBUG-107171 Change-Id: Idf71ccdc1d59f472c17084a36b5d7879c4d959c0 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-10-19 12:35:24 +00:00
if (QQmlJSScope::ConstPtr type = p.type())
return type->isListProperty();
return false;
Support value type lists in qmltc Generate list of values in qmltc when possible, by using QList<T> instead of QQmlListProperty<T>, e.g., when T is an int or a QColor.. Fixes: QTBUG-100313 Change-Id: Ifd84cbb550437854fb156a295435240cef446e61 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-06-29 15:21:49 +00:00
}
qmltc: Enforce basic required properties Types in QML can expose "required" properties. A required property is a property that should be initialized when an instance of the type is built. Instantiating a type without initializing its required properties is an hard error. Currently, `qmltc` generated types do not respect the semantic of "required" properties. Instead, `qmltc` will generally default-initialize a required property without notifying the user of the error. `qmtlc`, so as to respect the semantic of required properties, will now require the user to pass an initial value for all required properties at construction time. To do so, `qmltc` will now generate a new inner record, `RequiredPropertiesBundle`, for each compiled top-level type, that contains the required amount of data to initialize each top-level required property that is reachable from the compiled type. An instance of `RequiredPropertiesBundle` will be required, as long as the type presents at least one required property, in the user-facing constructor for the generated type. The information stored in the instance will later be used to provide an initial value for each required property during the construction of the component. An intermediate representation for `RequiredPropertiesBundle` was added to "qmltcoutputir.h". `QmltcCodeWriter`, the component responsible for writing the final C++ code, was modified to take into consideration the presence, or lack thereof, of a `RequiredPropertiesBundle` and output the necessary code when required. The code taking care of populating the various IRs was modified to populate a `RequiredPropertiesBundle` for top-level components as necessary. Similarly, the code populating the parameters of the user-facing constructor was modified to require an instance of `RequiredPropertiesBundle` when necessary. The code that populates the body of the user-facing constructor for top-level types was modified to make use of the parameter by tying into the existing structure for setting initial values. `qmltc` uses a user-provided callback to allow the user to set the initial values for properties when constructing a top-level component. The body of the user-facing constructor was modified to compose the user-provided callback with a callable that sets the initial values for top-level required properties based on the bundle of data in the new `RequiredPropertiesBundle` instance. The code that populates the body of the user-facing constructor was moved into its own free-function, `compileRootExternalConstructorBody`, to be slightly more explicit about the structure of the code. A new test was provided to evaluate, some basic cases for the new behavior. Some pre-existing tests, which made use of required properties, were modified to comply with the new generated API. The documentation for `qmltc` was modified with a note about the new behavior. Task-number: QTBUG-120698 Change-Id: I1e916dcd91ae976629dad8adc7eacc6390bce7e9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2024-03-25 12:13:28 +00:00
static QList<QQmlJSMetaProperty> unboundRequiredProperties(
const QQmlJSScope::ConstPtr &type,
QmltcTypeResolver *resolver
) {
QList<QQmlJSMetaProperty> requiredProperties{};
auto isPropertyRequired = [&type, &resolver](const auto &property) {
if (!type->isPropertyRequired(property.propertyName()))
return false;
if (type->hasPropertyBindings(property.propertyName()))
return false;
if (property.isAlias()) {
QQmlJSUtils::AliasResolutionVisitor aliasVisitor;
QQmlJSUtils::ResolvedAlias result =
QQmlJSUtils::resolveAlias(resolver, property, type, aliasVisitor);
if (result.kind != QQmlJSUtils::AliasTarget_Property)
return false;
// If the top level alias targets a property that is in
// the top level scope and that property is required, then
// we will already pick up the property during one of the
// iterations.
// Setting the property or the alias is the same so we
// discard one of the two, as otherwise we would require
// the user to pass two values for the same property ,in
// this case the alias.
//
// For example in:
//
// ```
// Item {
// id: self
// required property int foo
// property alias bar: self.foo
// }
// ```
//
// Both foo and bar are required but setting one or the
// other is the same operation so that we should choose
// only one.
if (result.owner == type &&
type->isPropertyRequired(result.property.propertyName()))
return false;
if (result.owner->hasPropertyBindings(result.property.propertyName()))
return false;
}
return true;
};
const auto properties = type->properties();
std::copy_if(properties.cbegin(), properties.cend(),
std::back_inserter(requiredProperties), isPropertyRequired);
std::sort(requiredProperties.begin(), requiredProperties.end(),
[](const auto &left, const auto &right) {
return left.propertyName() < right.propertyName();
});
return requiredProperties;
}
// Populates the internal representation for a
// RequiredPropertiesBundle, a class that acts as a bundle of initial
// values that should be set for the required properties of a type.
static void compileRequiredPropertiesBundle(
QmltcType &current,
const QQmlJSScope::ConstPtr &type,
QmltcTypeResolver *resolver
) {
QList<QQmlJSMetaProperty> requiredProperties = unboundRequiredProperties(type, resolver);
if (requiredProperties.isEmpty())
return;
current.requiredPropertiesBundle.emplace();
current.requiredPropertiesBundle->name = u"RequiredPropertiesBundle"_s;
current.requiredPropertiesBundle->members.reserve(requiredProperties.size());
std::transform(requiredProperties.cbegin(), requiredProperties.cend(),
std::back_inserter(current.requiredPropertiesBundle->members),
[](const QQmlJSMetaProperty &property) {
QString type = qIsReferenceTypeList(property)
? u"const QList<%1*>&"_s.arg(
QmlCompiler: Rename sequences' "valueType" to "elementType" "valueType" is ambiguous. The prevailing meaning is a type that's passed by value in QML. We mean the type of the list contents (or elements) here. Change-Id: Iaf4c0efe272dc6ec7511d2361e7e5ce475936fba Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2025-08-25 09:00:35 +00:00
property.type()->elementType()->internalName())
qmltc: Enforce basic required properties Types in QML can expose "required" properties. A required property is a property that should be initialized when an instance of the type is built. Instantiating a type without initializing its required properties is an hard error. Currently, `qmltc` generated types do not respect the semantic of "required" properties. Instead, `qmltc` will generally default-initialize a required property without notifying the user of the error. `qmtlc`, so as to respect the semantic of required properties, will now require the user to pass an initial value for all required properties at construction time. To do so, `qmltc` will now generate a new inner record, `RequiredPropertiesBundle`, for each compiled top-level type, that contains the required amount of data to initialize each top-level required property that is reachable from the compiled type. An instance of `RequiredPropertiesBundle` will be required, as long as the type presents at least one required property, in the user-facing constructor for the generated type. The information stored in the instance will later be used to provide an initial value for each required property during the construction of the component. An intermediate representation for `RequiredPropertiesBundle` was added to "qmltcoutputir.h". `QmltcCodeWriter`, the component responsible for writing the final C++ code, was modified to take into consideration the presence, or lack thereof, of a `RequiredPropertiesBundle` and output the necessary code when required. The code taking care of populating the various IRs was modified to populate a `RequiredPropertiesBundle` for top-level components as necessary. Similarly, the code populating the parameters of the user-facing constructor was modified to require an instance of `RequiredPropertiesBundle` when necessary. The code that populates the body of the user-facing constructor for top-level types was modified to make use of the parameter by tying into the existing structure for setting initial values. `qmltc` uses a user-provided callback to allow the user to set the initial values for properties when constructing a top-level component. The body of the user-facing constructor was modified to compose the user-provided callback with a callable that sets the initial values for top-level required properties based on the bundle of data in the new `RequiredPropertiesBundle` instance. The code that populates the body of the user-facing constructor was moved into its own free-function, `compileRootExternalConstructorBody`, to be slightly more explicit about the structure of the code. A new test was provided to evaluate, some basic cases for the new behavior. Some pre-existing tests, which made use of required properties, were modified to comply with the new generated API. The documentation for `qmltc` was modified with a note about the new behavior. Task-number: QTBUG-120698 Change-Id: I1e916dcd91ae976629dad8adc7eacc6390bce7e9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2024-03-25 12:13:28 +00:00
: u"passByConstRefOrValue<%1>"_s.arg(
property.type()->augmentedInternalName());
return QmltcVariable{ type, property.propertyName() };
});
}
static void compileRootExternalConstructorBody(
QmltcType& current,
const QQmlJSScope::ConstPtr &type
) {
current.externalCtor.body << u"// document root:"_s;
// if it's document root, we want to create our QQmltcObjectCreationBase
// that would store all the created objects
current.externalCtor.body << u"QQmltcObjectCreationBase<%1> objectHolder;"_s.arg(
type->internalName());
current.externalCtor.body
<< u"QQmltcObjectCreationHelper creator = objectHolder.view();"_s;
current.externalCtor.body << u"creator.set(0, this);"_s; // special case
QString initializerName = u"initializer"_s;
if (current.requiredPropertiesBundle) {
// Compose new initializer based on the initial values for required properties.
current.externalCtor.body << u"auto newInitializer = [&](auto& propertyInitializer) {"_s;
for (const auto& member : current.requiredPropertiesBundle->members) {
current.externalCtor.body << u" propertyInitializer.%1(requiredPropertiesBundle.%2);"_s.arg(
QmltcPropertyData(member.name).write, member.name
);
}
current.externalCtor.body << u" initializer(propertyInitializer);"_s;
current.externalCtor.body << u"};"_s;
initializerName = u"newInitializer"_s;
}
// now call init
current.externalCtor.body << current.init.name
+ u"(&creator, engine, QQmlContextData::get(engine->rootContext()), /* "
u"endInit */ true, %1);"_s.arg(initializerName);
};
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
Q_LOGGING_CATEGORY(lcQmltcCompiler, "qml.qmltc.compiler", QtWarningMsg);
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 QString QmltcCodeGenerator::privateEngineName = u"ePriv"_s;
const QString QmltcCodeGenerator::typeCountName = u"q_qmltc_typeCount"_s;
qmltc: Learn to set QML context for objects Add the minimal test along the way. The most we can do at present is to check that root object's context is set correctly. Comprehensive tests require binding compilation The QQmlParserStatus::classBegin() shenanigans are skipped for now Change-Id: I5c28c8a4406753dcf0fc93d968800b4376ec6017 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-12 08:28:33 +00:00
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
QmltcCompiler::QmltcCompiler(const QString &url, QmltcTypeResolver *resolver, QmltcVisitor *visitor,
QQmlJSLogger *logger)
: m_url(url), m_typeResolver(resolver), m_visitor(visitor), m_logger(logger)
Long live (dummy-for-now) qmltc! This is a stub commit that introduces qmltc as a binary We don't even attempt to generate any code here yet Task-number: QTBUG-84368 Change-Id: I98da17d839970a2561f501f3b9d6b1e1310e0e01 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-16 07:35:33 +00:00
{
Q_UNUSED(m_typeResolver);
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
Q_ASSERT(!hasErrors());
Long live (dummy-for-now) qmltc! This is a stub commit that introduces qmltc as a binary We don't even attempt to generate any code here yet Task-number: QTBUG-84368 Change-Id: I98da17d839970a2561f501f3b9d6b1e1310e0e01 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-16 07:35:33 +00:00
}
qmltc: Use prototype/codegenerator in qmltccompiler While deeper integration requires more changes, we can already establish the general relationship now. The idea: slowly migrate to the proper qmltc compiler code. To achieve this, we can step by step distill prototype's code generator in the qmltc code generation. Right now, do it at the highest level by compiling everything with the prototype's codegen (as before) but within the "proper" qmltc compiler Change-Id: I8a1e62f0559ff437ec2a4b0727147a441367c8e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-10 08:37:01 +00:00
// needed due to std::unique_ptr<CodeGenerator> with CodeGenerator being
// incomplete type in the header (~std::unique_ptr<> fails with a static_assert)
QmltcCompiler::~QmltcCompiler() = default;
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
QString QmltcCompiler::newSymbol(const QString &base)
{
QString symbol = base;
symbol.replace(QLatin1String("."), QLatin1String("_"));
while (symbol.startsWith(QLatin1Char('_')) && symbol.size() >= 2
&& (symbol[1].isUpper() || symbol[1] == QLatin1Char('_'))) {
symbol.remove(0, 1);
}
if (!m_symbols.contains(symbol)) {
m_symbols.insert(symbol, 1);
} else {
symbol += u"_" + QString::number(m_symbols[symbol]++);
}
return symbol;
}
qmltc: Get rid of Qml IR We no longer need it so remove it from the prototype code. Some code that updates QQmlJSScopes is still necessary on the other hand Pick-to: 6.4 Change-Id: I22c9bbcf30ff080a69f360f2f3a0515b18e8e2f3 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-03 11:52:47 +00:00
void QmltcCompiler::compile(const QmltcCompilerInfo &info)
Long live (dummy-for-now) qmltc! This is a stub commit that introduces qmltc as a binary We don't even attempt to generate any code here yet Task-number: QTBUG-84368 Change-Id: I98da17d839970a2561f501f3b9d6b1e1310e0e01 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-16 07:35:33 +00:00
{
m_info = info;
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
Q_ASSERT(!m_info.outputCppFile.isEmpty());
Q_ASSERT(!m_info.outputHFile.isEmpty());
Q_ASSERT(!m_info.resourcePath.isEmpty());
qmltc: Get rid of Qml IR We no longer need it so remove it from the prototype code. Some code that updates QQmlJSScopes is still necessary on the other hand Pick-to: 6.4 Change-Id: I22c9bbcf30ff080a69f360f2f3a0515b18e8e2f3 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-06-03 11:52:47 +00:00
// Note: we only compile "pure" QML types. any component-wrapped type is
// expected to appear through a binding
qmltc: Use prototype/codegenerator in qmltccompiler While deeper integration requires more changes, we can already establish the general relationship now. The idea: slowly migrate to the proper qmltc compiler code. To achieve this, we can step by step distill prototype's code generator in the qmltc code generation. Right now, do it at the highest level by compiling everything with the prototype's codegen (as before) but within the "proper" qmltc compiler Change-Id: I8a1e62f0559ff437ec2a4b0727147a441367c8e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-10 08:37:01 +00:00
const auto isComponent = [](const QQmlJSScope::ConstPtr &type) {
auto base = type->baseType();
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
return base && base->internalName() == u"QQmlComponent"_s;
qmltc: Use prototype/codegenerator in qmltccompiler While deeper integration requires more changes, we can already establish the general relationship now. The idea: slowly migrate to the proper qmltc compiler code. To achieve this, we can step by step distill prototype's code generator in the qmltc code generation. Right now, do it at the highest level by compiling everything with the prototype's codegen (as before) but within the "proper" qmltc compiler Change-Id: I8a1e62f0559ff437ec2a4b0727147a441367c8e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-10 08:37:01 +00:00
};
qmltc: Uniquely name internal method that provides QML document URL To enable unity builds of the generated code we have to name our static methods in a unique way, so make URL method use QML document url as part of the name. This should be unique enough since we don't have two exactly named QML files within a module Fixes: QTBUG-102765 Pick-to: 6.3 Change-Id: I2618b19709e63149d68efc45b6726e84ba64981f Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-26 08:42:16 +00:00
QmltcCodeGenerator generator { m_url, m_visitor };
qmltc: Learn to set QML context for objects Add the minimal test along the way. The most we can do at present is to check that root object's context is set correctly. Comprehensive tests require binding compilation The QQmlParserStatus::classBegin() shenanigans are skipped for now Change-Id: I5c28c8a4406753dcf0fc93d968800b4376ec6017 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-12 08:28:33 +00:00
QmltcMethod urlMethod;
qmltc: Uniquely name internal method that provides QML document URL To enable unity builds of the generated code we have to name our static methods in a unique way, so make URL method use QML document url as part of the name. This should be unique enough since we don't have two exactly named QML files within a module Fixes: QTBUG-102765 Pick-to: 6.3 Change-Id: I2618b19709e63149d68efc45b6726e84ba64981f Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-26 08:42:16 +00:00
compileUrlMethod(urlMethod, generator.urlMethodName());
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
m_urlMethodName = urlMethod.name;
qmltc: Use prototype/codegenerator in qmltccompiler While deeper integration requires more changes, we can already establish the general relationship now. The idea: slowly migrate to the proper qmltc compiler code. To achieve this, we can step by step distill prototype's code generator in the qmltc code generation. Right now, do it at the highest level by compiling everything with the prototype's codegen (as before) but within the "proper" qmltc compiler Change-Id: I8a1e62f0559ff437ec2a4b0727147a441367c8e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-10 08:37:01 +00:00
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
// sort inline components to compile them in the right order
// a inherits b => b needs to be defined in the cpp file before a!
// r is the root => r needs to be compiled at the end!
// otherwise => sort them by inline component names to have consistent output
auto sortedInlineComponentNames = m_visitor->inlineComponentNames();
std::sort(sortedInlineComponentNames.begin(), sortedInlineComponentNames.end(),
[&](const InlineComponentOrDocumentRootName &a,
const InlineComponentOrDocumentRootName &b) {
const auto *inlineComponentAName = std::get_if<InlineComponentNameType>(&a);
const auto *inlineComponentBName = std::get_if<InlineComponentNameType>(&b);
QmltcCompiler: Adhere to Compare requirement ("!(a < a)") The Compare requirements [1] say: > The return value of the function call operation applied to an object of > a type satisfying Compare, when contextually converted to bool, yields > true if the first argument of the call appears before the second in the > strict weak ordering relation induced by this type, and false otherwise. That requirement was violated here, because passing the same value for both arguments would return true, since the inlineComponentB->inherits(inlineComponentA) check returns true when both inline components are the same. Add an equality check to fix that. Fixes a build failure when building with CXXFLAGS='-D_GLIBCXX_DEBUG': /usr/include/c++/13/bits/stl_algo.h:4892: In function: void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = QList<variant<QString, monostate> >::iterator; _Compare = QmltcCompiler::compile(const QmltcCompilerInfo&)::<lambda(const QmltcCompiler::InlineComponentOrDocumentRootName&, const QmltcCompiler::InlineComponentOrDocumentRootName&)>] Error: comparison doesn't meet irreflexive requirements, assert(!(a < a)). Objects involved in the operation: instance "functor" @ 0x7ffec14329f8 { type = QmltcCompiler::compile(QmltcCompilerInfo const&)::{lambda(std::variant<QString, std::monostate> const&, std::variant<QString, std::monostate> const&)#1}; } iterator::value_type "ordered type" { type = std::variant<QString, std::monostate>; } Aborted (core dumped) ninja: build stopped: subcommand failed. GDB backtrace: Program terminated with signal SIGABRT, Aborted. #0 __pthread_kill_implementation (threadid=<optimized out>, signo=signo@entry=6, no_tid=no_tid@entry=0) at ./nptl/pthread_kill.c:44 44 ./nptl/pthread_kill.c: No such file or directory. (gdb) bt #0 __pthread_kill_implementation (threadid=<optimized out>, signo=signo@entry=6, no_tid=no_tid@entry=0) at ./nptl/pthread_kill.c:44 #1 0x00007fbe6b4a815f in __pthread_kill_internal (signo=6, threadid=<optimized out>) at ./nptl/pthread_kill.c:78 #2 0x00007fbe6b45a472 in __GI_raise (sig=sig@entry=6) at ../sysdeps/posix/raise.c:26 #3 0x00007fbe6b4444b2 in __GI_abort () at ./stdlib/abort.c:79 #4 0x00007fbe6b6a300d in ?? () from /lib/x86_64-linux-gnu/libstdc++.so.6 #5 0x0000560ae899bec4 in std::sort<QList<std::variant<QString, std::monostate> >::iterator, QmltcCompiler::compile(const QmltcCompilerInfo&)::<lambda(const QmltcCompiler::InlineComponentOrDocumentRootName&, const QmltcCompiler::InlineComponentOrDocumentRootName&)> >(QList<std::variant<QString, std::monostate> >::iterator, QList<std::variant<QString, std::monostate> >::iterator, struct {...}) (__first=..., __last=..., __comp=...) at /usr/include/c++/13/bits/stl_algo.h:4892 #6 0x0000560ae898bd67 in QmltcCompiler::compile (this=0x7ffec1432e80, info=...) at /home/michi/development/git/qt5/qtdeclarative/tools/qmltc/qmltccompiler.cpp:85 #7 0x0000560ae89264b6 in main (argc=23, argv=0x7ffec1434fc8) at /home/michi/development/git/qt5/qtdeclarative/tools/qmltc/main.cpp:284 [1] https://en.cppreference.com/w/cpp/named_req/Compare Change-Id: Ie8934b8381ef217c1f8860ee110f6fa2aa0c86fa Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2023-12-07 17:41:13 +00:00
if (inlineComponentAName == inlineComponentBName)
return false;
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
// the root comes at last, so (a < b) == true when b is the root and a is not
if (inlineComponentAName && !inlineComponentBName)
return true;
// b requires a to be declared before b when b inherits from a, therefore (a < b)
// == true
if (inlineComponentAName && inlineComponentBName) {
QQmlJSScope::ConstPtr inlineComponentA = m_visitor->inlineComponent(a);
QQmlJSScope::ConstPtr inlineComponentB = m_visitor->inlineComponent(b);
if (inlineComponentB->inherits(inlineComponentA)) {
return true;
} else if (inlineComponentA->inherits(inlineComponentB)) {
return false;
} else {
// fallback to default sorting based on names
return *inlineComponentAName < *inlineComponentBName;
}
}
Q_ASSERT(!inlineComponentAName || !inlineComponentBName);
// a is the root or both a and b are the root
return false;
});
qmltc: Use prototype/codegenerator in qmltccompiler While deeper integration requires more changes, we can already establish the general relationship now. The idea: slowly migrate to the proper qmltc compiler code. To achieve this, we can step by step distill prototype's code generator in the qmltc code generation. Right now, do it at the highest level by compiling everything with the prototype's codegen (as before) but within the "proper" qmltc compiler Change-Id: I8a1e62f0559ff437ec2a4b0727147a441367c8e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-10 08:37:01 +00:00
QList<QmltcType> compiledTypes;
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
for (const auto &inlineComponent : sortedInlineComponentNames) {
const QList<QQmlJSScope::ConstPtr> &pureTypes = m_visitor->pureQmlTypes(inlineComponent);
Q_ASSERT(!pureTypes.empty());
const QQmlJSScope::ConstPtr &root = pureTypes.front();
if (isComponent(root)) {
qmltc: Use prototype/codegenerator in qmltccompiler While deeper integration requires more changes, we can already establish the general relationship now. The idea: slowly migrate to the proper qmltc compiler code. To achieve this, we can step by step distill prototype's code generator in the qmltc code generation. Right now, do it at the highest level by compiling everything with the prototype's codegen (as before) but within the "proper" qmltc compiler Change-Id: I8a1e62f0559ff437ec2a4b0727147a441367c8e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-10 08:37:01 +00:00
compiledTypes.emplaceBack(); // create empty type
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
const auto compile = [&](QmltcType &current, const QQmlJSScope::ConstPtr &type) {
generator.generate_initCodeForTopLevelComponent(current, type);
};
compileType(compiledTypes.back(), root, compile);
} else {
const auto compile = [this](QmltcType &current, const QQmlJSScope::ConstPtr &type) {
compileTypeElements(current, type);
};
for (const auto &type : pureTypes) {
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
Q_ASSERT(type->scopeType() == QQmlSA::ScopeType::QMLScope);
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
compiledTypes.emplaceBack(); // create empty type
compileType(compiledTypes.back(), type, compile);
}
qmltc: Use prototype/codegenerator in qmltccompiler While deeper integration requires more changes, we can already establish the general relationship now. The idea: slowly migrate to the proper qmltc compiler code. To achieve this, we can step by step distill prototype's code generator in the qmltc code generation. Right now, do it at the highest level by compiling everything with the prototype's codegen (as before) but within the "proper" qmltc compiler Change-Id: I8a1e62f0559ff437ec2a4b0727147a441367c8e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-10 08:37:01 +00:00
}
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
}
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
qmltc: Use prototype/codegenerator in qmltccompiler While deeper integration requires more changes, we can already establish the general relationship now. The idea: slowly migrate to the proper qmltc compiler code. To achieve this, we can step by step distill prototype's code generator in the qmltc code generation. Right now, do it at the highest level by compiling everything with the prototype's codegen (as before) but within the "proper" qmltc compiler Change-Id: I8a1e62f0559ff437ec2a4b0727147a441367c8e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-10 08:37:01 +00:00
if (hasErrors())
return;
qmltc: add cmake api and simplest file writer Also update tests to include the generated file. While the content is meaningless, it's good enough to check that the file is include-able at this stage Task-number: QTBUG-84368 Task-number: QTBUG-96040 Change-Id: I155826a52090c5b13d14be6330813dc5a27f28e5 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-17 15:01:56 +00:00
QmltcProgram program;
program.url = m_url;
program.cppPath = m_info.outputCppFile;
program.hPath = m_info.outputHFile;
qmltc: support user-specified namespaces in the generated code Already during the prototyping phase, conflicts in class names were encountered within Qt code base. Those could be avoided by namespaces. Initial qmltc logic was using meaningless "q_qmltc" namespace, so let's improve that by allowing user-specified namespaces + making Qt's own QML files (compiled to C++) being available under QT_NAMESPACE. The latter is achieved by providing (and using) the internal version of a qmltc-invoking function Task-number: QTBUG-84368 Task-number: QTBUG-96040 Change-Id: I99cdf1baba8838c093b6b469f6744869f72af093 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-20 09:14:52 +00:00
program.outNamespace = m_info.outputNamespace;
qmltc: export generated classes Add QMLTC_EXPORT_MACRO_NAME and QMLTC_EXPORT_FILE_NAME arguments to qt_add_qml_module() that allows the user to export qmltc-generated code from its library. The qmltc-generated code will include the header-file specified in QMLTC_EXPORT_FILE_NAME and will be exported with the macro specified by QMLTC_EXPORT_MACRO_NAME. Leave both options unspecified to not export the code generated by qmltc. Describe the options in the documentation and write a test to see if the class really has an export macro in the generated code: 1) tst_qmltc_qprocess will test if the macro and the header are correctly inserted in the generated code. 2) tst_qmltc_{no,}diskcache will test if the generated code can still be used from a static library. Fixes: QTBUG-106840 Task-number: QTBUG-96040 Change-Id: I554f03bcdf043e8114e42f51a7289a5c00de4f89 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-12-22 16:24:16 +00:00
program.exportMacro = m_info.exportMacro;
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
program.compiledTypes = compiledTypes;
qmltc: Use correct output C++ file names within a module Due to custom basenames in CMake qmltc can create non-default file names that contain the generated C++. This would cause troubles when locally importing such a custom-marked QML file from the same module. Resolve this by introducing a qrc-based mapping from source file name to C++ header file that the generated code would be put into Use the mapping information inside QmltcVisitor so that imported types are properly set Doing so, with some additional fixes around file paths collection, allows to get rid of the prototype code completely Fixes: QTBUG-104094 Pick-to: 6.4 Change-Id: I6a54774addf303449f35915df501ab3f47470c44 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-06-10 07:41:27 +00:00
program.includes = m_visitor->cppIncludeFiles();
qmltc: export generated classes Add QMLTC_EXPORT_MACRO_NAME and QMLTC_EXPORT_FILE_NAME arguments to qt_add_qml_module() that allows the user to export qmltc-generated code from its library. The qmltc-generated code will include the header-file specified in QMLTC_EXPORT_FILE_NAME and will be exported with the macro specified by QMLTC_EXPORT_MACRO_NAME. Leave both options unspecified to not export the code generated by qmltc. Describe the options in the documentation and write a test to see if the class really has an export macro in the generated code: 1) tst_qmltc_qprocess will test if the macro and the header are correctly inserted in the generated code. 2) tst_qmltc_{no,}diskcache will test if the generated code can still be used from a static library. Fixes: QTBUG-106840 Task-number: QTBUG-96040 Change-Id: I554f03bcdf043e8114e42f51a7289a5c00de4f89 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-12-22 16:24:16 +00:00
if (!m_info.exportMacro.isEmpty() && !m_info.exportInclude.isEmpty())
program.includes += (m_info.exportInclude);
qmltc: Learn to set QML context for objects Add the minimal test along the way. The most we can do at present is to check that root object's context is set correctly. Comprehensive tests require binding compilation The QQmlParserStatus::classBegin() shenanigans are skipped for now Change-Id: I5c28c8a4406753dcf0fc93d968800b4376ec6017 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-12 08:28:33 +00:00
program.urlMethod = urlMethod;
qmltc: add cmake api and simplest file writer Also update tests to include the generated file. While the content is meaningless, it's good enough to check that the file is include-able at this stage Task-number: QTBUG-84368 Task-number: QTBUG-96040 Change-Id: I155826a52090c5b13d14be6330813dc5a27f28e5 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-17 15:01:56 +00:00
QmltcOutput out;
QmltcOutputWrapper code(out);
QmltcCodeWriter::write(code, program);
Long live (dummy-for-now) qmltc! This is a stub commit that introduces qmltc as a binary We don't even attempt to generate any code here yet Task-number: QTBUG-84368 Change-Id: I98da17d839970a2561f501f3b9d6b1e1310e0e01 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-16 07:35:33 +00:00
}
qmltc: Uniquely name internal method that provides QML document URL To enable unity builds of the generated code we have to name our static methods in a unique way, so make URL method use QML document url as part of the name. This should be unique enough since we don't have two exactly named QML files within a module Fixes: QTBUG-102765 Pick-to: 6.3 Change-Id: I2618b19709e63149d68efc45b6726e84ba64981f Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-26 08:42:16 +00:00
void QmltcCompiler::compileUrlMethod(QmltcMethod &urlMethod, const QString &urlMethodName)
qmltc: Learn to set QML context for objects Add the minimal test along the way. The most we can do at present is to check that root object's context is set correctly. Comprehensive tests require binding compilation The QQmlParserStatus::classBegin() shenanigans are skipped for now Change-Id: I5c28c8a4406753dcf0fc93d968800b4376ec6017 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-12 08:28:33 +00:00
{
qmltc: Uniquely name internal method that provides QML document URL To enable unity builds of the generated code we have to name our static methods in a unique way, so make URL method use QML document url as part of the name. This should be unique enough since we don't have two exactly named QML files within a module Fixes: QTBUG-102765 Pick-to: 6.3 Change-Id: I2618b19709e63149d68efc45b6726e84ba64981f Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-26 08:42:16 +00:00
urlMethod.name = urlMethodName;
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
urlMethod.returnType = u"const QUrl&"_s;
urlMethod.body << u"static QUrl url {QStringLiteral(\"qrc:%1\")};"_s.arg(m_info.resourcePath);
urlMethod.body << u"return url;"_s;
urlMethod.declarationPrefixes << u"static"_s;
urlMethod.modifiers << u"noexcept"_s;
qmltc: Learn to set QML context for objects Add the minimal test along the way. The most we can do at present is to check that root object's context is set correctly. Comprehensive tests require binding compilation The QQmlParserStatus::classBegin() shenanigans are skipped for now Change-Id: I5c28c8a4406753dcf0fc93d968800b4376ec6017 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-12 08:28:33 +00:00
}
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
void QmltcCompiler::compileType(
QmltcType &current, const QQmlJSScope::ConstPtr &type,
std::function<void(QmltcType &, const QQmlJSScope::ConstPtr &)> compileElements)
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
{
qmltc: Learn to collect C++ includes for a type hierarchy We need this to be able to properly include types, properties, etc. The strategy right now is very exhaustive but it seems necessary (afair) to be able to support weird cases with non-trivial forward declarations As a drive-by, fix some mistakes in QQmlJSScopeVisitor and its qmltc's counterpart Task-number: QTBUG-84368 Change-Id: I97719222598af85886821c0bf6e0e788770c8924 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-28 12:18:04 +00:00
Q_ASSERT(!type->internalName().isEmpty());
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
current.cppType = type->internalName();
qmltc: Learn to collect C++ includes for a type hierarchy We need this to be able to properly include types, properties, etc. The strategy right now is very exhaustive but it seems necessary (afair) to be able to support weird cases with non-trivial forward declarations As a drive-by, fix some mistakes in QQmlJSScopeVisitor and its qmltc's counterpart Task-number: QTBUG-84368 Change-Id: I97719222598af85886821c0bf6e0e788770c8924 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-28 12:18:04 +00:00
Q_ASSERT(!type->baseType()->internalName().isEmpty());
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
const QString baseClass = type->baseType()->internalName();
qmltc: Introduce object creation infrastructure The so-far strategy is the following: * allocate a linear storage for the QObject pointers using QQmltcObjectCreationBase (to reference the to-be-created objects) * "type-erase" the QQmltcObjectCreationBase into QQmltcObjectCreationHelper (so now we don't need to know the template specialization across different QML documents): non-document roots' ctors can accept QQmltcObjectCreationHelper as an input parameter * use QQmltcObjectCreationHelper to set object pointers into the storage when creating all the objects (also from other QML documents) * use QQmltcObjectCreationHelper later to retrieve necessary objects during creation finalization Provide basic implementation for the first and second bullets straight away This model seems to allow to hide the details of QQmltcObjectCreationBase interaction within the QML top-level document root (the type that we instantiate in the user code), which is very convenient Task-number: QTBUG-84368 Change-Id: I04cf64c54e48f169acfd4337cf93a58a05336b3b Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-22 10:02:37 +00:00
const auto rootType = m_visitor->result();
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
const InlineComponentOrDocumentRootName name = type->enclosingInlineComponentName();
QQmlJSScope::ConstPtr inlineComponentType = m_visitor->inlineComponent(name);
Q_ASSERT(inlineComponentType);
qmltc: Introduce object creation infrastructure The so-far strategy is the following: * allocate a linear storage for the QObject pointers using QQmltcObjectCreationBase (to reference the to-be-created objects) * "type-erase" the QQmltcObjectCreationBase into QQmltcObjectCreationHelper (so now we don't need to know the template specialization across different QML documents): non-document roots' ctors can accept QQmltcObjectCreationHelper as an input parameter * use QQmltcObjectCreationHelper to set object pointers into the storage when creating all the objects (also from other QML documents) * use QQmltcObjectCreationHelper later to retrieve necessary objects during creation finalization Provide basic implementation for the first and second bullets straight away This model seems to allow to hide the details of QQmltcObjectCreationBase interaction within the QML top-level document root (the type that we instantiate in the user code), which is very convenient Task-number: QTBUG-84368 Change-Id: I04cf64c54e48f169acfd4337cf93a58a05336b3b Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-22 10:02:37 +00:00
const bool documentRoot = (type == rootType);
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
const bool inlineComponent = type->isInlineComponent();
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
const bool isAnonymous = !documentRoot || type->internalName().at(0).isLower();
qmltc: add singleton support Add singleton support to qmltc. Add the QML_SINGLETON annotation to the class, generate a static T* create(QQmlEngine*, QJSEngine*) method for the engine and also add test this new functionality. Fixes: QTBUG-106828 Change-Id: I7b6b39ab0c8a427b3166562c3f04cf4a7eaa20e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-28 18:04:44 +00:00
const bool isSingleton = type->isSingleton();
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
qmltc: Uniquely name internal method that provides QML document URL To enable unity builds of the generated code we have to name our static methods in a unique way, so make URL method use QML document url as part of the name. This should be unique enough since we don't have two exactly named QML files within a module Fixes: QTBUG-102765 Pick-to: 6.3 Change-Id: I2618b19709e63149d68efc45b6726e84ba64981f Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-26 08:42:16 +00:00
QmltcCodeGenerator generator { m_url, m_visitor };
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
current.baseClasses = { baseClass };
if (!documentRoot) {
Remove qmltc prototype code (2/N) - Migrate to the newer output ir classes (with adjustments) - Deduplicate code writer and remove now-unused output helpers from the prototype version - Remove old output ir Change-Id: Ie7fe5e6d47e18477c65af02cabd89a890628442c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-03 13:03:58 +00:00
// make document root a friend to allow it to access init and endInit
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
const QString rootInternalName =
m_visitor->inlineComponent(type->enclosingInlineComponentName())->internalName();
qmltc: fix GCC13 warnings "class X is implicitly friend with itself" This happens because the generated code contains class X { ~~~~ private: friend class X; // warning here }; Says GCC13 (e.g.): tests/auto/qml/qmltc/QmltcTests/.qmltc/qmltc_test_module/inlinecomponents.h:421:18: warning: class ‘QmltcTests::inlineComponents_IC0’ is implicitly friends with itself 421 | friend class inlineComponents_IC0; | ^~~~~~~~~~~~~~~~~~~~ It seems the intended check for documentRoot doesn't work in all cases, so do the check on the class-name level. There appears to be no -W flag to control this warning, therefore no apparent way to suppress it, so we need to fix it. Amends either b89a92053e1a4565d37f75831db1c6c90c21bce6 or 0990b892cab819f210120f8a9f9ca48522bde412. I didn't dig into it further. Pick-to: 6.6 6.5 Change-Id: I3fe653a398ea5b7a3e045fd3ea8dfb5d5c0f2e5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-08-01 15:32:25 +00:00
if (rootInternalName != current.cppType) // avoid GCC13 warning on self-befriending
current.otherCode << "friend class %1;"_L1.arg(rootInternalName);
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
}
if (documentRoot || inlineComponent) {
auto name = type->inlineComponentName()
? InlineComponentOrDocumentRootName(*type->inlineComponentName())
: InlineComponentOrDocumentRootName(RootDocumentNameType());
// make QQmltcObjectCreationBase<DocumentRoot> a friend to allow it to
// be created for the root object
current.otherCode << u"friend class QQmltcObjectCreationBase<%1>;"_s.arg(
inlineComponentType->internalName());
// generate typeCount for all components (root + inlineComponents)
QmltcMethod typeCountMethod;
typeCountMethod.name = QmltcCodeGenerator::typeCountName;
typeCountMethod.returnType = u"uint"_s;
typeCountMethod.body << u"return " + generator.generate_typeCount(name) + u";";
current.typeCount = typeCountMethod;
} else {
// make an immediate parent a friend since that parent
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
// would create the object through a non-public constructor
const auto realQmlScope = [](const QQmlJSScope::ConstPtr &scope) {
if (scope->isArrayScope())
return scope->parentScope();
return scope;
};
qmltc: Avoid befriending the root component twice When `qmltc` compiles a type to C++, if the type is not the root of the document, it will generate code to befriend the root component. Similarly, it will generate code to befriend the direct parent of the component. In both cases this is done as the component may be created from those other generated types by accessing some private members of the generated API. When a component is not the root of the document, is not an inline component and its parent is the root of the document, `qmltc` will generate the same friend declaration twice, once to befriend the root of the document and once to befriend the direct parent of the type. For example, if we have some component `Foo` and a root component that refers to it, say: ``` Window { Foo {} } ``` The generated code for `Foo` will befriend the generated type for the root component twice. While multiple friend declaration are not an issue, they are generally uncommon, as there is no reason to befriend something twice, so that they may generally stand out as an error or a typo, while making the code noisier. Thus, to avoid befriending the document root twice for generated non-root, non-inline components whose parent is the root of the document, the code that generates the friend declaration for the direct parent of such a component was conditioned on that parent not being the document root, as we would have already befriended it at that point of the compilation. Change-Id: Ie6eb4b786317c3c555718b594c689c085b4f2336 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2024-03-18 11:51:59 +00:00
const auto& realScope = realQmlScope(type->parentScope());
if (realScope != rootType) {
current.otherCode << u"friend class %1;"_s.arg(realScope->internalName());
}
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
}
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
// make QQmltcObjectCreationHelper a friend of every type since it provides
// useful helper methods for all types
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
current.otherCode << u"friend class QT_PREPEND_NAMESPACE(QQmltcObjectCreationHelper);"_s;
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
qmltc: Learn to collect C++ includes for a type hierarchy We need this to be able to properly include types, properties, etc. The strategy right now is very exhaustive but it seems necessary (afair) to be able to support weird cases with non-trivial forward declarations As a drive-by, fix some mistakes in QQmlJSScopeVisitor and its qmltc's counterpart Task-number: QTBUG-84368 Change-Id: I97719222598af85886821c0bf6e0e788770c8924 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-28 12:18:04 +00:00
current.mocCode = {
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
u"Q_OBJECT"_s,
qmltc: Learn to collect C++ includes for a type hierarchy We need this to be able to properly include types, properties, etc. The strategy right now is very exhaustive but it seems necessary (afair) to be able to support weird cases with non-trivial forward declarations As a drive-by, fix some mistakes in QQmlJSScopeVisitor and its qmltc's counterpart Task-number: QTBUG-84368 Change-Id: I97719222598af85886821c0bf6e0e788770c8924 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-28 12:18:04 +00:00
// Note: isAnonymous holds for non-root types in the document as well
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
type->isInlineComponent() ? (u"QML_NAMED_ELEMENT(%1)"_s.arg(*type->inlineComponentName()))
: (isAnonymous ? u"QML_ANONYMOUS"_s : u"QML_ELEMENT"_s),
qmltc: Learn to collect C++ includes for a type hierarchy We need this to be able to properly include types, properties, etc. The strategy right now is very exhaustive but it seems necessary (afair) to be able to support weird cases with non-trivial forward declarations As a drive-by, fix some mistakes in QQmlJSScopeVisitor and its qmltc's counterpart Task-number: QTBUG-84368 Change-Id: I97719222598af85886821c0bf6e0e788770c8924 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-28 12:18:04 +00:00
};
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
qmltc: Introduce object creation infrastructure The so-far strategy is the following: * allocate a linear storage for the QObject pointers using QQmltcObjectCreationBase (to reference the to-be-created objects) * "type-erase" the QQmltcObjectCreationBase into QQmltcObjectCreationHelper (so now we don't need to know the template specialization across different QML documents): non-document roots' ctors can accept QQmltcObjectCreationHelper as an input parameter * use QQmltcObjectCreationHelper to set object pointers into the storage when creating all the objects (also from other QML documents) * use QQmltcObjectCreationHelper later to retrieve necessary objects during creation finalization Provide basic implementation for the first and second bullets straight away This model seems to allow to hide the details of QQmltcObjectCreationBase interaction within the QML top-level document root (the type that we instantiate in the user code), which is very convenient Task-number: QTBUG-84368 Change-Id: I04cf64c54e48f169acfd4337cf93a58a05336b3b Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-22 10:02:37 +00:00
// add special member functions
Remove qmltc prototype code (2/N) - Migrate to the newer output ir classes (with adjustments) - Deduplicate code writer and remove now-unused output helpers from the prototype version - Remove old output ir Change-Id: Ie7fe5e6d47e18477c65af02cabd89a890628442c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-03 13:03:58 +00:00
current.baselineCtor.access = QQmlJSMetaMethod::Protected;
qmltc: add singleton support Add singleton support to qmltc. Add the QML_SINGLETON annotation to the class, generate a static T* create(QQmlEngine*, QJSEngine*) method for the engine and also add test this new functionality. Fixes: QTBUG-106828 Change-Id: I7b6b39ab0c8a427b3166562c3f04cf4a7eaa20e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-28 18:04:44 +00:00
if (documentRoot || inlineComponent || isSingleton) {
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
current.externalCtor.access = QQmlJSMetaMethod::Public;
} else {
current.externalCtor.access = QQmlJSMetaMethod::Protected;
}
qmltc: Introduce object creation infrastructure The so-far strategy is the following: * allocate a linear storage for the QObject pointers using QQmltcObjectCreationBase (to reference the to-be-created objects) * "type-erase" the QQmltcObjectCreationBase into QQmltcObjectCreationHelper (so now we don't need to know the template specialization across different QML documents): non-document roots' ctors can accept QQmltcObjectCreationHelper as an input parameter * use QQmltcObjectCreationHelper to set object pointers into the storage when creating all the objects (also from other QML documents) * use QQmltcObjectCreationHelper later to retrieve necessary objects during creation finalization Provide basic implementation for the first and second bullets straight away This model seems to allow to hide the details of QQmltcObjectCreationBase interaction within the QML top-level document root (the type that we instantiate in the user code), which is very convenient Task-number: QTBUG-84368 Change-Id: I04cf64c54e48f169acfd4337cf93a58a05336b3b Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-22 10:02:37 +00:00
current.init.access = QQmlJSMetaMethod::Protected;
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
current.beginClass.access = QQmlJSMetaMethod::Protected;
Remove qmltc prototype code (2/N) - Migrate to the newer output ir classes (with adjustments) - Deduplicate code writer and remove now-unused output helpers from the prototype version - Remove old output ir Change-Id: Ie7fe5e6d47e18477c65af02cabd89a890628442c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-03 13:03:58 +00:00
current.endInit.access = QQmlJSMetaMethod::Protected;
Separate script bindings from others in generated qmltc code Align script binding creation to QQmlObjectCreator model: simple bindings (e.g. literal, object, etc.) are created instantly when encountered; complex bindings (e.g. script, translation?) are posponed until QQmlObjectCreator::finalize() (in reality it is a bit more complicated). Make qmltc follow this logic by creating script bindings in a separate object creation step Additionally, this should theoretically improve performance of the object creation process as script bindings (that have interdependencies) would now re-trigger less as they are all centrally created at once (after simple bindings are already done). Note, however, that the specific order of binding creation between children may vary in comparison to QQmlObjectCreator Task-number: QTBUG-91956 Task-number: QTBUG-96269 Pick-to: 6.4 Change-Id: I25067adf7b16d0f1852a5108a0b6d6597ac28a53 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-27 15:03:44 +00:00
current.setComplexBindings.access = QQmlJSMetaMethod::Protected;
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
current.completeComponent.access = QQmlJSMetaMethod::Protected;
current.finalizeComponent.access = QQmlJSMetaMethod::Protected;
current.handleOnCompleted.access = QQmlJSMetaMethod::Protected;
qmltc: Introduce object creation infrastructure The so-far strategy is the following: * allocate a linear storage for the QObject pointers using QQmltcObjectCreationBase (to reference the to-be-created objects) * "type-erase" the QQmltcObjectCreationBase into QQmltcObjectCreationHelper (so now we don't need to know the template specialization across different QML documents): non-document roots' ctors can accept QQmltcObjectCreationHelper as an input parameter * use QQmltcObjectCreationHelper to set object pointers into the storage when creating all the objects (also from other QML documents) * use QQmltcObjectCreationHelper later to retrieve necessary objects during creation finalization Provide basic implementation for the first and second bullets straight away This model seems to allow to hide the details of QQmltcObjectCreationBase interaction within the QML top-level document root (the type that we instantiate in the user code), which is very convenient Task-number: QTBUG-84368 Change-Id: I04cf64c54e48f169acfd4337cf93a58a05336b3b Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-22 10:02:37 +00:00
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
current.propertyInitializer.name = u"PropertyInitializer"_s;
current.propertyInitializer.constructor.access = QQmlJSMetaMethod::Public;
current.propertyInitializer.constructor.name = current.propertyInitializer.name;
current.propertyInitializer.constructor.parameterList = {
QmltcVariable(u"%1&"_s.arg(current.cppType), u"component"_s)
};
current.propertyInitializer.component.cppType = current.cppType + u"&";
current.propertyInitializer.component.name = u"component"_s;
current.propertyInitializer.initializedCache.cppType = u"QSet<QString>"_s;
current.propertyInitializer.initializedCache.name = u"initializedCache"_s;
Remove qmltc prototype code (2/N) - Migrate to the newer output ir classes (with adjustments) - Deduplicate code writer and remove now-unused output helpers from the prototype version - Remove old output ir Change-Id: Ie7fe5e6d47e18477c65af02cabd89a890628442c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-03 13:03:58 +00:00
current.baselineCtor.name = current.cppType;
current.externalCtor.name = current.cppType;
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
current.init.name = u"QML_init"_s;
current.init.returnType = u"QQmlRefPointer<QQmlContextData>"_s;
current.beginClass.name = u"QML_beginClass"_s;
current.beginClass.returnType = u"void"_s;
current.endInit.name = u"QML_endInit"_s;
current.endInit.returnType = u"void"_s;
Separate script bindings from others in generated qmltc code Align script binding creation to QQmlObjectCreator model: simple bindings (e.g. literal, object, etc.) are created instantly when encountered; complex bindings (e.g. script, translation?) are posponed until QQmlObjectCreator::finalize() (in reality it is a bit more complicated). Make qmltc follow this logic by creating script bindings in a separate object creation step Additionally, this should theoretically improve performance of the object creation process as script bindings (that have interdependencies) would now re-trigger less as they are all centrally created at once (after simple bindings are already done). Note, however, that the specific order of binding creation between children may vary in comparison to QQmlObjectCreator Task-number: QTBUG-91956 Task-number: QTBUG-96269 Pick-to: 6.4 Change-Id: I25067adf7b16d0f1852a5108a0b6d6597ac28a53 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-27 15:03:44 +00:00
current.setComplexBindings.name = u"QML_setComplexBindings"_s;
current.setComplexBindings.returnType = u"void"_s;
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
current.completeComponent.name = u"QML_completeComponent"_s;
current.completeComponent.returnType = u"void"_s;
current.finalizeComponent.name = u"QML_finalizeComponent"_s;
current.finalizeComponent.returnType = u"void"_s;
current.handleOnCompleted.name = u"QML_handleOnCompleted"_s;
current.handleOnCompleted.returnType = u"void"_s;
QmltcVariable creator(u"QQmltcObjectCreationHelper*"_s, u"creator"_s);
QmltcVariable engine(u"QQmlEngine*"_s, u"engine"_s);
QmltcVariable parent(u"QObject*"_s, u"parent"_s, u"nullptr"_s);
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
QmltcVariable initializedCache(
u"[[maybe_unused]] const QSet<QString>&"_s,
u"initializedCache"_s,
u"{}"_s
);
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
QmltcVariable ctxtdata(u"const QQmlRefPointer<QQmlContextData>&"_s, u"parentContext"_s);
QmltcVariable finalizeFlag(u"bool"_s, u"canFinalize"_s);
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
current.baselineCtor.parameterList = { parent };
Remove redundant parameter from generated special functions of qmltc Finalization argument is unused in binding processing functions so there is no need to have it in the first place Pick-to: 6.4 Change-Id: I800b43b5114dacc54c3e852adc02bc6be66dd54e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-27 15:28:33 +00:00
current.endInit.parameterList = { creator, engine };
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
current.setComplexBindings.parameterList = { creator, engine, initializedCache };
Remove redundant parameter from generated special functions of qmltc Finalization argument is unused in binding processing functions so there is no need to have it in the first place Pick-to: 6.4 Change-Id: I800b43b5114dacc54c3e852adc02bc6be66dd54e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-27 15:28:33 +00:00
current.handleOnCompleted.parameterList = { creator };
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
if (documentRoot || inlineComponent) {
Fix coverity warnings * Make things const where we can * Avoid copies where we can * Clarify some types * Remove dead code Coverity-Id: 454277 Coverity-Id: 454278 Coverity-Id: 454287 Coverity-Id: 454288 Coverity-Id: 454291 Coverity-Id: 454292 Coverity-Id: 454294 Coverity-Id: 454295 Change-Id: I56150aea78ea2b188083f99bf83816b121ef867a Reviewed-by: Semih Yavuz <semih.yavuz@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2024-04-10 06:34:27 +00:00
const QmltcVariable initializer(
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
u"[[maybe_unused]] qxp::function_ref<void(%1&)>"_s.arg(current.propertyInitializer.name),
u"initializer"_s,
u"[](%1&){}"_s.arg(current.propertyInitializer.name));
current.init.parameterList = { creator, engine, ctxtdata, finalizeFlag, initializer };
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
current.beginClass.parameterList = { creator, finalizeFlag };
current.completeComponent.parameterList = { creator, finalizeFlag };
current.finalizeComponent.parameterList = { creator, finalizeFlag };
qmltc: Enforce basic required properties Types in QML can expose "required" properties. A required property is a property that should be initialized when an instance of the type is built. Instantiating a type without initializing its required properties is an hard error. Currently, `qmltc` generated types do not respect the semantic of "required" properties. Instead, `qmltc` will generally default-initialize a required property without notifying the user of the error. `qmtlc`, so as to respect the semantic of required properties, will now require the user to pass an initial value for all required properties at construction time. To do so, `qmltc` will now generate a new inner record, `RequiredPropertiesBundle`, for each compiled top-level type, that contains the required amount of data to initialize each top-level required property that is reachable from the compiled type. An instance of `RequiredPropertiesBundle` will be required, as long as the type presents at least one required property, in the user-facing constructor for the generated type. The information stored in the instance will later be used to provide an initial value for each required property during the construction of the component. An intermediate representation for `RequiredPropertiesBundle` was added to "qmltcoutputir.h". `QmltcCodeWriter`, the component responsible for writing the final C++ code, was modified to take into consideration the presence, or lack thereof, of a `RequiredPropertiesBundle` and output the necessary code when required. The code taking care of populating the various IRs was modified to populate a `RequiredPropertiesBundle` for top-level components as necessary. Similarly, the code populating the parameters of the user-facing constructor was modified to require an instance of `RequiredPropertiesBundle` when necessary. The code that populates the body of the user-facing constructor for top-level types was modified to make use of the parameter by tying into the existing structure for setting initial values. `qmltc` uses a user-provided callback to allow the user to set the initial values for properties when constructing a top-level component. The body of the user-facing constructor was modified to compose the user-provided callback with a callable that sets the initial values for top-level required properties based on the bundle of data in the new `RequiredPropertiesBundle` instance. The code that populates the body of the user-facing constructor was moved into its own free-function, `compileRootExternalConstructorBody`, to be slightly more explicit about the structure of the code. A new test was provided to evaluate, some basic cases for the new behavior. Some pre-existing tests, which made use of required properties, were modified to comply with the new generated API. The documentation for `qmltc` was modified with a note about the new behavior. Task-number: QTBUG-120698 Change-Id: I1e916dcd91ae976629dad8adc7eacc6390bce7e9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2024-03-25 12:13:28 +00:00
compileRequiredPropertiesBundle(current, type, m_typeResolver);
if (current.requiredPropertiesBundle) {
QmltcVariable bundle{
u"const %1&"_s.arg(current.requiredPropertiesBundle->name),
u"requiredPropertiesBundle"_s,
};
current.externalCtor.parameterList = { engine, bundle, parent, initializer };
} else {
current.externalCtor.parameterList = { engine, parent, initializer };
}
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
} else {
Remove qmltc prototype code (2/N) - Migrate to the newer output ir classes (with adjustments) - Deduplicate code writer and remove now-unused output helpers from the prototype version - Remove old output ir Change-Id: Ie7fe5e6d47e18477c65af02cabd89a890628442c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-03 13:03:58 +00:00
current.externalCtor.parameterList = { creator, engine, parent };
qmltc: Introduce object creation infrastructure The so-far strategy is the following: * allocate a linear storage for the QObject pointers using QQmltcObjectCreationBase (to reference the to-be-created objects) * "type-erase" the QQmltcObjectCreationBase into QQmltcObjectCreationHelper (so now we don't need to know the template specialization across different QML documents): non-document roots' ctors can accept QQmltcObjectCreationHelper as an input parameter * use QQmltcObjectCreationHelper to set object pointers into the storage when creating all the objects (also from other QML documents) * use QQmltcObjectCreationHelper later to retrieve necessary objects during creation finalization Provide basic implementation for the first and second bullets straight away This model seems to allow to hide the details of QQmltcObjectCreationBase interaction within the QML top-level document root (the type that we instantiate in the user code), which is very convenient Task-number: QTBUG-84368 Change-Id: I04cf64c54e48f169acfd4337cf93a58a05336b3b Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-22 10:02:37 +00:00
current.init.parameterList = { creator, engine, ctxtdata };
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
current.beginClass.parameterList = { creator };
current.completeComponent.parameterList = { creator };
current.finalizeComponent.parameterList = { creator };
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
}
Remove qmltc prototype code (2/N) - Migrate to the newer output ir classes (with adjustments) - Deduplicate code writer and remove now-unused output helpers from the prototype version - Remove old output ir Change-Id: Ie7fe5e6d47e18477c65af02cabd89a890628442c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-03 13:03:58 +00:00
current.externalCtor.initializerList = { current.baselineCtor.name + u"(" + parent.name
+ u")" };
Use QQmlJSUtils::hasCompositeBase() in qmltccompiler.cpp We have this helper function now Change-Id: Id3b4f750e0e3aed6dd10e78b2a1e0d7123b09691 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:07:30 +00:00
if (QQmlJSUtils::hasCompositeBase(type)) {
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
// call parent's (QML type's) basic ctor from this. that one will take
// care about QObject::setParent()
Remove qmltc prototype code (2/N) - Migrate to the newer output ir classes (with adjustments) - Deduplicate code writer and remove now-unused output helpers from the prototype version - Remove old output ir Change-Id: Ie7fe5e6d47e18477c65af02cabd89a890628442c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-03 13:03:58 +00:00
current.baselineCtor.initializerList = { baseClass + u"(" + parent.name + u")" };
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
} else {
// default call to ctor is enough, but QQml_setParent_noEvent() is
// needed (note: faster? version of QObject::setParent())
Remove qmltc prototype code (2/N) - Migrate to the newer output ir classes (with adjustments) - Deduplicate code writer and remove now-unused output helpers from the prototype version - Remove old output ir Change-Id: Ie7fe5e6d47e18477c65af02cabd89a890628442c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-03 13:03:58 +00:00
current.baselineCtor.body << u"QQml_setParent_noEvent(this, " + parent.name + u");";
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
}
// compilation stub:
tooling: silence -Wextra-semi-stmt silence clang's -Wextra-semi-stmt Pick-to: 6.4 Change-Id: I5dee9ec46b44076f0fc0590399131b1b267e1ad2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-10-05 11:37:07 +00:00
current.externalCtor.body << u"Q_UNUSED(engine)"_s;
qmltc: support basic inline components This patch adds basic inline component support to qmltc. Implementation details: * added tests: ** (for all tests: see if QQmlComponent would do the same thing) ** try simple inline components ** try inline components extending other inline components ** try recursive inline components (inline component A contain a B that itself contains a A) ** make sure ids in inline components are in their own context, and ** make sure alias inside of inline components work ** remove qmltc_qprocess that tests the error message when inline components are encountered ** test that inline components get their own context (by aliasing a property that they should not be able to see) ** test that also empty components work ** other tests inspired from those at tst_qqmllanguage * separate types depending on the inline component they belong in qmltcvisitor and qmltccompiler ** mostly by replacing T with QHash<QString, T>, where the belonging inline component name serves as hash key ** added a list of inline component names in qmltc * generate correct qmltc-code for inline components ** as they sometimes have mimic a document root and sometimes not ** generate their own "typeCount"-method ** fixed naming used in qmltc generated code by using the inline component names from the qqmljsscope. There is one missing feature (using inline components from other files, using QmlFileName.MyInlineComponent) that will be added in a separate commit. Fixes: QTBUG-106882 Change-Id: Iabe1a8b787027367d73d34bcd93c5f7b5480d217 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-09 11:47:28 +00:00
if (documentRoot || inlineComponent) {
qmltc: Enforce basic required properties Types in QML can expose "required" properties. A required property is a property that should be initialized when an instance of the type is built. Instantiating a type without initializing its required properties is an hard error. Currently, `qmltc` generated types do not respect the semantic of "required" properties. Instead, `qmltc` will generally default-initialize a required property without notifying the user of the error. `qmtlc`, so as to respect the semantic of required properties, will now require the user to pass an initial value for all required properties at construction time. To do so, `qmltc` will now generate a new inner record, `RequiredPropertiesBundle`, for each compiled top-level type, that contains the required amount of data to initialize each top-level required property that is reachable from the compiled type. An instance of `RequiredPropertiesBundle` will be required, as long as the type presents at least one required property, in the user-facing constructor for the generated type. The information stored in the instance will later be used to provide an initial value for each required property during the construction of the component. An intermediate representation for `RequiredPropertiesBundle` was added to "qmltcoutputir.h". `QmltcCodeWriter`, the component responsible for writing the final C++ code, was modified to take into consideration the presence, or lack thereof, of a `RequiredPropertiesBundle` and output the necessary code when required. The code taking care of populating the various IRs was modified to populate a `RequiredPropertiesBundle` for top-level components as necessary. Similarly, the code populating the parameters of the user-facing constructor was modified to require an instance of `RequiredPropertiesBundle` when necessary. The code that populates the body of the user-facing constructor for top-level types was modified to make use of the parameter by tying into the existing structure for setting initial values. `qmltc` uses a user-provided callback to allow the user to set the initial values for properties when constructing a top-level component. The body of the user-facing constructor was modified to compose the user-provided callback with a callable that sets the initial values for top-level required properties based on the bundle of data in the new `RequiredPropertiesBundle` instance. The code that populates the body of the user-facing constructor was moved into its own free-function, `compileRootExternalConstructorBody`, to be slightly more explicit about the structure of the code. A new test was provided to evaluate, some basic cases for the new behavior. Some pre-existing tests, which made use of required properties, were modified to comply with the new generated API. The documentation for `qmltc` was modified with a note about the new behavior. Task-number: QTBUG-120698 Change-Id: I1e916dcd91ae976629dad8adc7eacc6390bce7e9 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2024-03-25 12:13:28 +00:00
compileRootExternalConstructorBody(current, type);
qmltc: Introduce object creation infrastructure The so-far strategy is the following: * allocate a linear storage for the QObject pointers using QQmltcObjectCreationBase (to reference the to-be-created objects) * "type-erase" the QQmltcObjectCreationBase into QQmltcObjectCreationHelper (so now we don't need to know the template specialization across different QML documents): non-document roots' ctors can accept QQmltcObjectCreationHelper as an input parameter * use QQmltcObjectCreationHelper to set object pointers into the storage when creating all the objects (also from other QML documents) * use QQmltcObjectCreationHelper later to retrieve necessary objects during creation finalization Provide basic implementation for the first and second bullets straight away This model seems to allow to hide the details of QQmltcObjectCreationBase interaction within the QML top-level document root (the type that we instantiate in the user code), which is very convenient Task-number: QTBUG-84368 Change-Id: I04cf64c54e48f169acfd4337cf93a58a05336b3b Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-22 10:02:37 +00:00
} else {
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
current.externalCtor.body << u"// not document root:"_s;
qmltc: Introduce object creation infrastructure The so-far strategy is the following: * allocate a linear storage for the QObject pointers using QQmltcObjectCreationBase (to reference the to-be-created objects) * "type-erase" the QQmltcObjectCreationBase into QQmltcObjectCreationHelper (so now we don't need to know the template specialization across different QML documents): non-document roots' ctors can accept QQmltcObjectCreationHelper as an input parameter * use QQmltcObjectCreationHelper to set object pointers into the storage when creating all the objects (also from other QML documents) * use QQmltcObjectCreationHelper later to retrieve necessary objects during creation finalization Provide basic implementation for the first and second bullets straight away This model seems to allow to hide the details of QQmltcObjectCreationBase interaction within the QML top-level document root (the type that we instantiate in the user code), which is very convenient Task-number: QTBUG-84368 Change-Id: I04cf64c54e48f169acfd4337cf93a58a05336b3b Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-22 10:02:37 +00:00
// just call init, we don't do any setup here otherwise
Remove qmltc prototype code (2/N) - Migrate to the newer output ir classes (with adjustments) - Deduplicate code writer and remove now-unused output helpers from the prototype version - Remove old output ir Change-Id: Ie7fe5e6d47e18477c65af02cabd89a890628442c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-03 13:03:58 +00:00
current.externalCtor.body << current.init.name
qmltc: Introduce object creation infrastructure The so-far strategy is the following: * allocate a linear storage for the QObject pointers using QQmltcObjectCreationBase (to reference the to-be-created objects) * "type-erase" the QQmltcObjectCreationBase into QQmltcObjectCreationHelper (so now we don't need to know the template specialization across different QML documents): non-document roots' ctors can accept QQmltcObjectCreationHelper as an input parameter * use QQmltcObjectCreationHelper to set object pointers into the storage when creating all the objects (also from other QML documents) * use QQmltcObjectCreationHelper later to retrieve necessary objects during creation finalization Provide basic implementation for the first and second bullets straight away This model seems to allow to hide the details of QQmltcObjectCreationBase interaction within the QML top-level document root (the type that we instantiate in the user code), which is very convenient Task-number: QTBUG-84368 Change-Id: I04cf64c54e48f169acfd4337cf93a58a05336b3b Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-22 10:02:37 +00:00
+ u"(creator, engine, QQmlData::get(parent)->outerContext);";
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
}
qmltc: Learn to set QML context for objects Add the minimal test along the way. The most we can do at present is to check that root object's context is set correctly. Comprehensive tests require binding compilation The QQmlParserStatus::classBegin() shenanigans are skipped for now Change-Id: I5c28c8a4406753dcf0fc93d968800b4376ec6017 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-12 08:28:33 +00:00
qmltc: add singleton support Add singleton support to qmltc. Add the QML_SINGLETON annotation to the class, generate a static T* create(QQmlEngine*, QJSEngine*) method for the engine and also add test this new functionality. Fixes: QTBUG-106828 Change-Id: I7b6b39ab0c8a427b3166562c3f04cf4a7eaa20e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-28 18:04:44 +00:00
if (isSingleton) {
// see https://doc.qt.io/qt-6/qqmlengine.html#QML_SINGLETON for context
current.mocCode.append(u"QML_SINGLETON"_s);
auto &staticCreate = current.staticCreate.emplace();
staticCreate.comments
<< u"Used by the engine for singleton creation."_s
<< u"See also \\l {https://doc.qt.io/qt-6/qqmlengine.html#QML_SINGLETON}."_s;
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
staticCreate.type = QQmlJSMetaMethodType::StaticMethod;
qmltc: add singleton support Add singleton support to qmltc. Add the QML_SINGLETON annotation to the class, generate a static T* create(QQmlEngine*, QJSEngine*) method for the engine and also add test this new functionality. Fixes: QTBUG-106828 Change-Id: I7b6b39ab0c8a427b3166562c3f04cf4a7eaa20e2 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-28 18:04:44 +00:00
staticCreate.access = QQmlJSMetaMethod::Public;
staticCreate.name = u"create"_s;
staticCreate.returnType = u"%1 *"_s.arg(current.cppType);
QmltcVariable jsEngine(u"QJSEngine*"_s, u"jsEngine"_s);
staticCreate.parameterList = { engine, jsEngine };
staticCreate.body << u"Q_UNUSED(jsEngine);"_s
<< u"%1 *result = new %1(engine, nullptr);"_s.arg(current.cppType)
<< u"return result;"_s;
}
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
auto postponedQmlContextSetup = generator.generate_initCode(current, type);
Address TODOs in qmltc tool Deal with low hanging fruits. Remove outdated TODOs. Fix the rest. Many things are still open Pick-to: 6.4 Change-Id: Ia2cd0724552b1116c34d12a30a4c911ee42e15d6 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-27 11:36:04 +00:00
generator.generate_endInitCode(current, type);
Separate script bindings from others in generated qmltc code Align script binding creation to QQmlObjectCreator model: simple bindings (e.g. literal, object, etc.) are created instantly when encountered; complex bindings (e.g. script, translation?) are posponed until QQmlObjectCreator::finalize() (in reality it is a bit more complicated). Make qmltc follow this logic by creating script bindings in a separate object creation step Additionally, this should theoretically improve performance of the object creation process as script bindings (that have interdependencies) would now re-trigger less as they are all centrally created at once (after simple bindings are already done). Note, however, that the specific order of binding creation between children may vary in comparison to QQmlObjectCreator Task-number: QTBUG-91956 Task-number: QTBUG-96269 Pick-to: 6.4 Change-Id: I25067adf7b16d0f1852a5108a0b6d6597ac28a53 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-27 15:03:44 +00:00
generator.generate_setComplexBindingsCode(current, type);
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
generator.generate_beginClassCode(current, type);
generator.generate_completeComponentCode(current, type);
generator.generate_finalizeComponentCode(current, type);
generator.generate_handleOnCompletedCode(current, type);
compileElements(current, type);
}
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
template<typename Iterator>
static Iterator partitionBindings(Iterator first, Iterator last)
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
{
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
// NB: the code generator cares about script bindings being processed at a
// later point, so we should sort or partition the range. we do a stable
// partition since the relative order of binding evaluation affects the UI
return std::stable_partition(first, last, [](const QQmlJSMetaPropertyBinding &b) {
Separate script bindings from others in generated qmltc code Align script binding creation to QQmlObjectCreator model: simple bindings (e.g. literal, object, etc.) are created instantly when encountered; complex bindings (e.g. script, translation?) are posponed until QQmlObjectCreator::finalize() (in reality it is a bit more complicated). Make qmltc follow this logic by creating script bindings in a separate object creation step Additionally, this should theoretically improve performance of the object creation process as script bindings (that have interdependencies) would now re-trigger less as they are all centrally created at once (after simple bindings are already done). Note, however, that the specific order of binding creation between children may vary in comparison to QQmlObjectCreator Task-number: QTBUG-91956 Task-number: QTBUG-96269 Pick-to: 6.4 Change-Id: I25067adf7b16d0f1852a5108a0b6d6597ac28a53 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-27 15:03:44 +00:00
// we want complex bindings to be at the end, so do the negation
return !QmltcCompiler::isComplexBinding(b);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
});
}
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
// Populates the propertyInitializer of the current type based on the
// available properties.
//
// A propertyInitializer is a generated class that provides a
// restricted interface that only allows setting property values and
// internally keep tracks of which properties where actually set,
// intended to be used to allow the user to set up the initial values
// when creating an instance of a component.
//
// For each property of the current type that is known, is not private
// and is writable, a setter method is generated.
// Each setter method knows how to set a specific property, so as to
// provide a strongly typed interface to property setting, as if the
// relevant C++ type was used directly.
//
// Each setter uses the write method for the proprerty when available
// and otherwise falls back to a the more generic
// `QObject::setProperty` for properties where a WRITE method is not
// available or in scope.
qmltc: Don't crash on missing type information Pick-to: 6.10 6.9 6.8 Fixes: QTBUG-136355 Change-Id: I0cf56674b451187a3483f4dfefbf6e1ccb275d04 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Semih Yavuz <semih.yavuz@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2025-07-11 13:52:57 +00:00
void QmltcCompiler::compilePropertyInitializer(
QmltcType &current, const QQmlJSScope::ConstPtr &type) {
static auto isFromExtension
= [](const QQmlJSMetaProperty &property, const QQmlJSScope::ConstPtr &scope) {
return scope->ownerOfProperty(scope, property.propertyName()).extensionSpecifier
!= QQmlJSScope::NotExtension;
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
};
current.propertyInitializer.constructor.initializerList << u"component{component}"_s;
qmltc: Don't crash on missing type information Pick-to: 6.10 6.9 6.8 Fixes: QTBUG-136355 Change-Id: I0cf56674b451187a3483f4dfefbf6e1ccb275d04 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Semih Yavuz <semih.yavuz@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2025-07-11 13:52:57 +00:00
const auto properties = type->properties().values();
for (const auto &property: properties) {
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
if (property.index() == -1) continue;
if (property.isPrivate()) continue;
qmltc: Support setting initial values for reference list properties When `qmltc` compiles a QML type to C++, it generates a proxy object for the compiled type, `PropertyInitializer`, that knowns how to set the top-level property of the component. A user can then pass a call-back to the constructor for the compiled type and use an instance of the generated `PropertyInitializer` to set the initial values for the top-level properties of the component. Currently, the generated `PropertyInitializer` would refuse to generate a setter for properties whose type is a list of object types, impeding the user from being able to set the initial values for properties of this kind. To allow setting the initial values for properties whose type is a list of object types, `qmltc` will generate a setter for those properties when generating the `PropertyInitializer` class for a type. The free function `compilePropertyInitializer` in "qmltccompiler.cpp", that is responsible for generating the `PropertyInitializer` class for a type, was modified to produce a setter for properties whose type is a list of object types. The test that verifies the initial values behavior was modified to have representative cases for the modified feature. Fixes: QTBUG-120700 Change-Id: I4a023263ca3dfa3c77c11d1522b8be47b7958109 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2024-03-20 14:49:34 +00:00
if (!property.isWritable() && !qIsReferenceTypeList(property)) continue;
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
const QString name = property.propertyName();
qmltc: Don't crash on missing type information Pick-to: 6.10 6.9 6.8 Fixes: QTBUG-136355 Change-Id: I0cf56674b451187a3483f4dfefbf6e1ccb275d04 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Semih Yavuz <semih.yavuz@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2025-07-11 13:52:57 +00:00
const auto propertyType = property.type();
if (propertyType.isNull()) {
recordError(type->sourceLocation(), u"Type of property '%1' is unknown"_s.arg(name));
continue;
}
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
current.propertyInitializer.propertySetters.emplace_back();
auto& compiledSetter = current.propertyInitializer.propertySetters.back();
compiledSetter.userVisible = true;
compiledSetter.returnType = u"void"_s;
compiledSetter.name = QmltcPropertyData(property).write;
qmltc: Support setting initial values for reference list properties When `qmltc` compiles a QML type to C++, it generates a proxy object for the compiled type, `PropertyInitializer`, that knowns how to set the top-level property of the component. A user can then pass a call-back to the constructor for the compiled type and use an instance of the generated `PropertyInitializer` to set the initial values for the top-level properties of the component. Currently, the generated `PropertyInitializer` would refuse to generate a setter for properties whose type is a list of object types, impeding the user from being able to set the initial values for properties of this kind. To allow setting the initial values for properties whose type is a list of object types, `qmltc` will generate a setter for those properties when generating the `PropertyInitializer` class for a type. The free function `compilePropertyInitializer` in "qmltccompiler.cpp", that is responsible for generating the `PropertyInitializer` class for a type, was modified to produce a setter for properties whose type is a list of object types. The test that verifies the initial values behavior was modified to have representative cases for the modified feature. Fixes: QTBUG-120700 Change-Id: I4a023263ca3dfa3c77c11d1522b8be47b7958109 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2024-03-20 14:49:34 +00:00
if (qIsReferenceTypeList(property)) {
compiledSetter.parameterList.emplaceBack(
qmltc: Don't crash on missing type information Pick-to: 6.10 6.9 6.8 Fixes: QTBUG-136355 Change-Id: I0cf56674b451187a3483f4dfefbf6e1ccb275d04 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Semih Yavuz <semih.yavuz@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2025-07-11 13:52:57 +00:00
QQmlJSUtils::constRefify(
QmlCompiler: Rename sequences' "valueType" to "elementType" "valueType" is ambiguous. The prevailing meaning is a type that's passed by value in QML. We mean the type of the list contents (or elements) here. Change-Id: Iaf4c0efe272dc6ec7511d2361e7e5ce475936fba Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2025-08-25 09:00:35 +00:00
u"QList<%1*>"_s.arg(propertyType->elementType()->internalName())),
qmltc: Support setting initial values for reference list properties When `qmltc` compiles a QML type to C++, it generates a proxy object for the compiled type, `PropertyInitializer`, that knowns how to set the top-level property of the component. A user can then pass a call-back to the constructor for the compiled type and use an instance of the generated `PropertyInitializer` to set the initial values for the top-level properties of the component. Currently, the generated `PropertyInitializer` would refuse to generate a setter for properties whose type is a list of object types, impeding the user from being able to set the initial values for properties of this kind. To allow setting the initial values for properties whose type is a list of object types, `qmltc` will generate a setter for those properties when generating the `PropertyInitializer` class for a type. The free function `compilePropertyInitializer` in "qmltccompiler.cpp", that is responsible for generating the `PropertyInitializer` class for a type, was modified to produce a setter for properties whose type is a list of object types. The test that verifies the initial values behavior was modified to have representative cases for the modified feature. Fixes: QTBUG-120700 Change-Id: I4a023263ca3dfa3c77c11d1522b8be47b7958109 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2024-03-20 14:49:34 +00:00
name + u"_", QString()
);
} else {
compiledSetter.parameterList.emplaceBack(
QQmlJSUtils::constRefify(getUnderlyingType(property)), name + u"_", QString()
);
}
if (qIsReferenceTypeList(property)) {
compiledSetter.body << u"QQmlListReference list_ref_(&%1, \"%2\");"_s.arg(
current.propertyInitializer.component.name, name
);
compiledSetter.body << u"list_ref_.clear();"_s;
compiledSetter.body << u"for (const auto& list_item_ : %1_)"_s.arg(name);
compiledSetter.body << u" list_ref_.append(list_item_);"_s;
} else if (
QQmlJSUtils::bindablePropertyHasDefaultAccessor(property, QQmlJSUtils::PropertyAccessor_Write)
) {
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
compiledSetter.body << u"%1.%2().setValue(%3_);"_s.arg(
current.propertyInitializer.component.name, property.bindable(), name);
qmltc: Ensure usage of generated setters in `PropertyInitializer` When `qmltc` compiles a QML type to C++, it generates a proxy object for the compiled type, `PropertyInitializer`, that knows how to set the top-level property of the component. A user can then pass a call-back to the constructor for the compiled type and use an instance of the generated `PropertyInitializer` to set the initial values for the top-level properties of the component. For each top-level property, the generated `PropertyInitializer` generates a setter. Based on various parameters, the generated setter can have a different body. Generally, the generated setter will prefer calling back to the component setter for the properties when that is available. When that is not the case, the generated setter would fall-back to a more general approach based on `QObject::setProperty`, which has additional overhead. This second approach will currently be chosen, when generating the setter for an owned property of the compiled type. While `qmltc` will generate a typed setter for those properties, on the C++ side, at the point where `PropertyInitializer` is compiled, the inspected owned properties, that come from the QML side, will not have a write accessor, which in turn makes the generated code fall-back to the more general implementation for the setter of those properties. To ensure that the generated setters for `PropertyInitializer` use a write accessor when present, `compilePropertyInitializer`, which takes care of producing the code for the generated `PropertyInitializer`, was modified to special case the generation of the setter for properties that are owned by the compiled type, ensuring that the generated setter will be used to set the initial value for the property. Change-Id: I0c34d6dd9d85a613d1e8909e94a584bf976a009f Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2024-03-20 15:04:27 +00:00
} else if (type->hasOwnProperty(name)) {
compiledSetter.body << u"%1.%2(%3_);"_s.arg(
current.propertyInitializer.component.name, QmltcPropertyData(property).write, name);
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
} else if (property.write().isEmpty() || isFromExtension(property, type)) {
// We can end here if a WRITE method is not available or
// if the method is available but not in this scope, so
// that we fallback to the string-based setters..
//
// For example, types that makes use of QML_EXTENDED
// types, will have the extension types properties
// available and with a WRITE method, but the WRITE method
// will not be available to the extended type, from C++,
// as the type does not directly inherit from the
// extension type.
//
// We specifically scope `setProperty` to `QObject` as
// certain types might have shadowed the method.
// For example, in QtQuick, some types have a property
// called `property` with a `setProperty` WRITE method
// that will produce the shadowing.
compiledSetter.body << u"%1.QObject::setProperty(\"%2\", QVariant::fromValue(%2_));"_s.arg(
current.propertyInitializer.component.name, name);
} else {
compiledSetter.body << u"%1.%2(%3_);"_s.arg(
current.propertyInitializer.component.name, property.write(), name);
}
qmltc: Wrap raw string literal in QStringLiteral Without this, QT_NO_CAST_FROM_ASCII builds would fail. Amends 361b601620073351013b516e9f7cf9f5173b9ce7 Pick-to: 6.8 Fixes: QTBUG-130081 Change-Id: Ifd5a4194a989953b7f0bc5f882b877eccb62cce8 Reviewed-by: Semih Yavuz <semih.yavuz@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2024-10-15 13:20:39 +00:00
compiledSetter.body << u"%1.insert(QStringLiteral(\"%2\"));"_s.arg(
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
current.propertyInitializer.initializedCache.name, name);
}
}
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
void QmltcCompiler::compileTypeElements(QmltcType &current, const QQmlJSScope::ConstPtr &type)
{
qmltc: Compile QML enums into C++ Task-number: QTBUG-84368 Change-Id: Idf6c724496c807477ce0914ab0d32a80a9b90b5a Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 10:43:44 +00:00
// compile components of a type:
// - enums
// - properties
// - methods
// - bindings
const auto enums = type->ownEnumerations();
current.enums.reserve(enums.size());
for (auto it = enums.begin(); it != enums.end(); ++it)
compileEnum(current, it.value());
qmltc: Compile QML methods to C++ This also requires some changes to the output IR + couple things could also be fixed while at it Task-number: QTBUG-84368 Change-Id: Ie1535cbbe36cd874e9787ea91fe85b638326de20 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-01 15:18:30 +00:00
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
auto properties = type->ownProperties().values();
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
current.properties.reserve(properties.size());
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
// Note: index() is the (future) meta property index, so make sure given
// properties are ordered by that index before compiling
std::sort(properties.begin(), properties.end(),
[](const QQmlJSMetaProperty &x, const QQmlJSMetaProperty &y) {
return x.index() < y.index();
});
Port from qAsConst() to std::as_const() We've been requiring C++17 since Qt 6.0, and our qAsConst use finally starts to bother us (QTBUG-99313), so time to port away from it now. Since qAsConst has exactly the same semantics as std::as_const (down to rvalue treatment, constexpr'ness and noexcept'ness), there's really nothing more to it than a global search-and-replace. Task-number: QTBUG-99313 Change-Id: I601bf70f020f511019ed28731ba53b14b765dbf0 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2022-10-06 09:30:50 +00:00
for (const QQmlJSMetaProperty &p : std::as_const(properties)) {
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
if (p.index() == -1) {
recordError(type->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
u"Internal error: property '%1' has incomplete information"_s.arg(
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
p.propertyName()));
continue;
}
if (p.isAlias()) {
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
compileAlias(current, p, type);
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
} else {
compileProperty(current, p, type);
}
}
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
const auto methods = type->ownMethods();
qmltc: Use QQmlJSScope::ownRuntimeFunctionIndex() in method compilation Now that the absolute runtime indices are present in QQmlJSScope, we can use them instead of QmlIR logic. Since this is possible, we no longer need prototype code and can use QmltcCompiler's compilation method instead The script bindings would be covered separately once the migration to QQmlJSScope-based compilation is done Change-Id: I21f2e1d59c351e95eeb47bb2af7124cc0ffe5f94 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-19 11:35:36 +00:00
for (const QQmlJSMetaMethod &m : methods)
compileMethod(current, m, type);
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
auto bindings = type->ownPropertyBindingsInQmlIROrder();
partitionBindings(bindings.begin(), bindings.end());
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
compilePropertyInitializer(current, type);
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
compileBinding(current, bindings.begin(), bindings.end(), type, { type });
qmltc: Compile QML enums into C++ Task-number: QTBUG-84368 Change-Id: Idf6c724496c807477ce0914ab0d32a80a9b90b5a Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 10:43:44 +00:00
}
void QmltcCompiler::compileEnum(QmltcType &current, const QQmlJSMetaEnum &e)
{
const auto intValues = e.values();
QStringList values;
values.reserve(intValues.size());
std::transform(intValues.cbegin(), intValues.cend(), std::back_inserter(values),
[](int x) { return QString::number(x); });
// structure: (C++ type name, enum keys, enum values, MOC line)
current.enums.emplaceBack(e.name(), e.keys(), std::move(values),
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
u"Q_ENUM(%1)"_s.arg(e.name()));
qmltc: learn to generate minimum amount of code - Finish output ir and the writer for it - Add simple compiler logic to generate dull class declarations Task-number: QTBUG-84368 Change-Id: I75be0f44b84ad3cfb1d862072d58b3bf87063d31 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2021-09-21 08:52:24 +00:00
}
QQmlJSMetaParameter: Encapsulate parameter information Previously, there were four lists that contained each one entry for each parameter. There was one list responsible for the names, types, type names and const-qualifiers but this was quite bothersome to use (e.g. they not always had the same length). This commit introduces QQmlJSMetaParameter to encapsulate all the information required when manipulating parameters. This reduce the 4 lists to one, making parameters easier to handle and QQmlJSMetaMethod easier to read. This is a purely refactoring change, no new functionality was added. Task-number: QTBUG-107625 Change-Id: Ia41b823c9e6294ee26e828071b802cac6b4058ce Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-11-10 10:38:51 +00:00
static QList<QmltcVariable>
compileMethodParameters(const QList<QQmlJSMetaParameter> &parameterInfos, bool allowUnnamed = false)
qmltc: Compile QML methods to C++ This also requires some changes to the output IR + couple things could also be fixed while at it Task-number: QTBUG-84368 Change-Id: Ie1535cbbe36cd874e9787ea91fe85b638326de20 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-01 15:18:30 +00:00
{
QList<QmltcVariable> parameters;
QQmlJSMetaParameter: Encapsulate parameter information Previously, there were four lists that contained each one entry for each parameter. There was one list responsible for the names, types, type names and const-qualifiers but this was quite bothersome to use (e.g. they not always had the same length). This commit introduces QQmlJSMetaParameter to encapsulate all the information required when manipulating parameters. This reduce the 4 lists to one, making parameters easier to handle and QQmlJSMetaMethod easier to read. This is a purely refactoring change, no new functionality was added. Task-number: QTBUG-107625 Change-Id: Ia41b823c9e6294ee26e828071b802cac6b4058ce Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-11-10 10:38:51 +00:00
const auto size = parameterInfos.size();
qmltc: Compile QML methods to C++ This also requires some changes to the output IR + couple things could also be fixed while at it Task-number: QTBUG-84368 Change-Id: Ie1535cbbe36cd874e9787ea91fe85b638326de20 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-01 15:18:30 +00:00
parameters.reserve(size);
for (qsizetype i = 0; i < size; ++i) {
QQmlJSMetaParameter: Encapsulate parameter information Previously, there were four lists that contained each one entry for each parameter. There was one list responsible for the names, types, type names and const-qualifiers but this was quite bothersome to use (e.g. they not always had the same length). This commit introduces QQmlJSMetaParameter to encapsulate all the information required when manipulating parameters. This reduce the 4 lists to one, making parameters easier to handle and QQmlJSMetaMethod easier to read. This is a purely refactoring change, no new functionality was added. Task-number: QTBUG-107625 Change-Id: Ia41b823c9e6294ee26e828071b802cac6b4058ce Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-11-10 10:38:51 +00:00
const auto &p = parameterInfos[i];
Q_ASSERT(p.type()); // assume verified
QString name = p.name();
qmltc: Compile QML methods to C++ This also requires some changes to the output IR + couple things could also be fixed while at it Task-number: QTBUG-84368 Change-Id: Ie1535cbbe36cd874e9787ea91fe85b638326de20 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-01 15:18:30 +00:00
Q_ASSERT(allowUnnamed || !name.isEmpty()); // assume verified
if (name.isEmpty() && allowUnnamed)
name = u"unnamed_" + QString::number(i);
qmltc: fix handlers for c++-signals Allow qmltc to generate handlers for c++-defined signals with const parameters by changing the safeguard to avoid type mismatch between slots and signals. First, remove the qOverload in the generated QObject::connect call to be able the connect slots and signals with different types (namely, pass by const references and pass by value should be interchangeable but is not allowed by qOverload). Second, save in QQmlJSMetaParameter when types are passed by pointer. Like this, qqmljsimportvisitor can check if a value type is indeed passed by value or const reference in a C++ signal. The same for reference types that need to be passed by (const and non-const) pointer. Print a message when an type is passed by argument in an incompatible way instead of letting qmltc generate uncompilable code, which makes the compiler print out cryptical messages. Third, add a qqmlcpptypehelpers template that decides if value types should be passed by value or reference, by letting the c++ compiler check if sizeof(T) > 3*sizeof(void*). Fixes: QTBUG-107625 Fixes: QTBUG-107622 Change-Id: I1a00532df591d10f74c1fd00dff5b7fccf40cb22 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-10-12 13:56:00 +00:00
QString internalName;
const QQmlJSScope::AccessSemantics semantics = p.type()->accessSemantics();
switch (semantics) {
case QQmlJSScope::AccessSemantics::Reference:
if (p.typeQualifier() == QQmlJSMetaParameter::Const)
internalName = u"const "_s;
internalName += u"%1*"_s.arg(p.type()->internalName());
break;
case QQmlJSScope::AccessSemantics::Value:
case QQmlJSScope::AccessSemantics::Sequence:
internalName = u"passByConstRefOrValue<%1>"_s.arg(p.type()->internalName());
break;
case QQmlJSScope::AccessSemantics::None:
Q_ASSERT(false); // or maybe print an error message
}
parameters.emplaceBack(internalName, name, QString());
qmltc: Compile QML methods to C++ This also requires some changes to the output IR + couple things could also be fixed while at it Task-number: QTBUG-84368 Change-Id: Ie1535cbbe36cd874e9787ea91fe85b638326de20 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-01 15:18:30 +00:00
}
return parameters;
}
qmltc: Use QQmlJSScope::ownRuntimeFunctionIndex() in method compilation Now that the absolute runtime indices are present in QQmlJSScope, we can use them instead of QmlIR logic. Since this is possible, we no longer need prototype code and can use QmltcCompiler's compilation method instead The script bindings would be covered separately once the migration to QQmlJSScope-based compilation is done Change-Id: I21f2e1d59c351e95eeb47bb2af7124cc0ffe5f94 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-19 11:35:36 +00:00
void QmltcCompiler::compileMethod(QmltcType &current, const QQmlJSMetaMethod &m,
const QQmlJSScope::ConstPtr &owner)
qmltc: Compile QML methods to C++ This also requires some changes to the output IR + couple things could also be fixed while at it Task-number: QTBUG-84368 Change-Id: Ie1535cbbe36cd874e9787ea91fe85b638326de20 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-01 15:18:30 +00:00
{
QmlCompiler: Assume missing return types to be "void" qmltyperegistrar leaves out "void" return types when generating methods and signals. Add those back when reading the files so that we don't have to special-case "void" in the compilers. Also, explicitly set the return type of QML signals to "void", for the same reason. Change-Id: I94cd9d005c458fe37160eccf5c14f02c53fc300a Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2024-06-18 14:17:16 +00:00
const QString returnType = m.returnType()->augmentedInternalName();
QQmlJSMetaParameter: Encapsulate parameter information Previously, there were four lists that contained each one entry for each parameter. There was one list responsible for the names, types, type names and const-qualifiers but this was quite bothersome to use (e.g. they not always had the same length). This commit introduces QQmlJSMetaParameter to encapsulate all the information required when manipulating parameters. This reduce the 4 lists to one, making parameters easier to handle and QQmlJSMetaMethod easier to read. This is a purely refactoring change, no new functionality was added. Task-number: QTBUG-107625 Change-Id: Ia41b823c9e6294ee26e828071b802cac6b4058ce Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-11-10 10:38:51 +00:00
const QList<QmltcVariable> compiledParams = compileMethodParameters(m.parameters());
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
const auto methodType = m.methodType();
qmltc: Compile QML methods to C++ This also requires some changes to the output IR + couple things could also be fixed while at it Task-number: QTBUG-84368 Change-Id: Ie1535cbbe36cd874e9787ea91fe85b638326de20 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-01 15:18:30 +00:00
QStringList code;
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
if (methodType != QQmlJSMetaMethodType::Signal) {
qmltc: Use QQmlJSScope::ownRuntimeFunctionIndex() in method compilation Now that the absolute runtime indices are present in QQmlJSScope, we can use them instead of QmlIR logic. Since this is possible, we no longer need prototype code and can use QmltcCompiler's compilation method instead The script bindings would be covered separately once the migration to QQmlJSScope-based compilation is done Change-Id: I21f2e1d59c351e95eeb47bb2af7124cc0ffe5f94 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-19 11:35:36 +00:00
QmltcCodeGenerator urlGenerator { m_url, m_visitor };
QmltcCodeGenerator::generate_callExecuteRuntimeFunction(
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
&code, urlGenerator.urlMethodName() + u"()",
owner->ownRuntimeFunctionIndex(m.jsFunctionIndex()), u"this"_s, returnType,
qmltc: Use QQmlJSScope::ownRuntimeFunctionIndex() in method compilation Now that the absolute runtime indices are present in QQmlJSScope, we can use them instead of QmlIR logic. Since this is possible, we no longer need prototype code and can use QmltcCompiler's compilation method instead The script bindings would be covered separately once the migration to QQmlJSScope-based compilation is done Change-Id: I21f2e1d59c351e95eeb47bb2af7124cc0ffe5f94 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-19 11:35:36 +00:00
compiledParams);
qmltc: Compile QML methods to C++ This also requires some changes to the output IR + couple things could also be fixed while at it Task-number: QTBUG-84368 Change-Id: Ie1535cbbe36cd874e9787ea91fe85b638326de20 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-01 15:18:30 +00:00
}
QmltcMethod compiled {};
compiled.returnType = returnType;
compiled.name = m.methodName();
compiled.parameterList = std::move(compiledParams);
compiled.body = std::move(code);
compiled.type = methodType;
compiled.access = m.access();
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
if (methodType != QQmlJSMetaMethodType::Signal) {
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
compiled.declarationPrefixes << u"Q_INVOKABLE"_s;
qmltc: Use QQmlJSScope::ownRuntimeFunctionIndex() in method compilation Now that the absolute runtime indices are present in QQmlJSScope, we can use them instead of QmlIR logic. Since this is possible, we no longer need prototype code and can use QmltcCompiler's compilation method instead The script bindings would be covered separately once the migration to QQmlJSScope-based compilation is done Change-Id: I21f2e1d59c351e95eeb47bb2af7124cc0ffe5f94 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-19 11:35:36 +00:00
compiled.userVisible = m.access() == QQmlJSMetaMethod::Public;
} else {
compiled.userVisible = !m.isImplicitQmlPropertyChangeSignal();
}
qmltc: Compile QML methods to C++ This also requires some changes to the output IR + couple things could also be fixed while at it Task-number: QTBUG-84368 Change-Id: Ie1535cbbe36cd874e9787ea91fe85b638326de20 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-01 15:18:30 +00:00
current.functions.emplaceBack(compiled);
}
qmltc: Add some sugar for generated reference-type-list properties When compiling a reference type list with qmltc into a QQmlListProperty, also generate helper methods to make the manipulation of those lists by the user easier in c++. For a list myList, generate the methods myListAt(), myListAppend(), ... as shown in the Birthdayparty example. Also add some documentation about the ownership of the arguments, and tests to see if the list can be accessed from C++. Task-number: QTBUG-107570 Change-Id: Iec0041015311639ead39660fdccf147749566592 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-10-17 13:27:12 +00:00
/*! \internal
Compiles an extra set of methods for Lists, that makes manipulating lists easier from C++
for the user.
*/
void QmltcCompiler::compileExtraListMethods(QmltcType &current, const QQmlJSMetaProperty &p)
{
QmltcPropertyData data(p);
QmlCompiler: Rename sequences' "valueType" to "elementType" "valueType" is ambiguous. The prevailing meaning is a type that's passed by value in QML. We mean the type of the list contents (or elements) here. Change-Id: Iaf4c0efe272dc6ec7511d2361e7e5ce475936fba Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2025-08-25 09:00:35 +00:00
const QString elementType = p.type()->elementType()->internalName() + u'*';
qmltc: Add some sugar for generated reference-type-list properties When compiling a reference type list with qmltc into a QQmlListProperty, also generate helper methods to make the manipulation of those lists by the user easier in c++. For a list myList, generate the methods myListAt(), myListAppend(), ... as shown in the Birthdayparty example. Also add some documentation about the ownership of the arguments, and tests to see if the list can be accessed from C++. Task-number: QTBUG-107570 Change-Id: Iec0041015311639ead39660fdccf147749566592 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-10-17 13:27:12 +00:00
const QString variableName = data.read + u"()"_s;
const QStringList ownershipWarning = {
u"\\note {This method does not change the ownership of its argument."_s,
u"The caller is responsible for setting the argument's \\c {QObject::parent} or"_s,
u"for ensuring that the argument lives long enough."_s,
u"For example, an argument created with \\c {createObject()} that has no parent"_s,
u"will eventually be garbage-collected, leaving a dangling pointer.}"_s
};
// generate append() sugar for users
{
QmltcMethod append{};
append.comments.emplaceBack(u"\\brief Append an element to %1."_s.arg(data.read));
append.comments << ownershipWarning;
append.returnType = u"void"_s;
append.name = u"%1Append"_s.arg(data.read);
QmlCompiler: Rename sequences' "valueType" to "elementType" "valueType" is ambiguous. The prevailing meaning is a type that's passed by value in QML. We mean the type of the list contents (or elements) here. Change-Id: Iaf4c0efe272dc6ec7511d2361e7e5ce475936fba Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2025-08-25 09:00:35 +00:00
append.parameterList.emplaceBack(elementType, u"toBeAppended"_s);
qmltc: Add some sugar for generated reference-type-list properties When compiling a reference type list with qmltc into a QQmlListProperty, also generate helper methods to make the manipulation of those lists by the user easier in c++. For a list myList, generate the methods myListAt(), myListAppend(), ... as shown in the Birthdayparty example. Also add some documentation about the ownership of the arguments, and tests to see if the list can be accessed from C++. Task-number: QTBUG-107570 Change-Id: Iec0041015311639ead39660fdccf147749566592 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-10-17 13:27:12 +00:00
append.body << u"auto q_qmltc_localList = %1;"_s.arg(variableName);
append.body
<< u"q_qmltc_localList.append(std::addressof(q_qmltc_localList), toBeAppended);"_s;
// append.body << u"Q_EMIT %1();"_s.arg(data.notify); // uncomment this when QTBUG-106587 is
// resolved
append.userVisible = true;
current.functions.emplaceBack(append);
}
// generate count() sugar for users
{
QmltcMethod count{};
count.comments.emplaceBack(u"\\brief Number of elements in %1."_s.arg(data.read));
count.returnType = u"int"_s;
count.name = u"%1Count"_s.arg(data.read);
count.body << u"auto q_qmltc_localList = %1;"_s.arg(variableName);
count.body << u"int result = q_qmltc_localList.count(std::addressof(q_qmltc_localList));"_s;
count.body << u"return result;"_s;
count.userVisible = true;
current.functions.emplaceBack(count);
}
// generate at() sugar for users
{
QmltcMethod at{};
at.comments.emplaceBack(u"\\brief Access an element in %1."_s.arg(data.read));
QmlCompiler: Rename sequences' "valueType" to "elementType" "valueType" is ambiguous. The prevailing meaning is a type that's passed by value in QML. We mean the type of the list contents (or elements) here. Change-Id: Iaf4c0efe272dc6ec7511d2361e7e5ce475936fba Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2025-08-25 09:00:35 +00:00
at.returnType = elementType;
qmltc: Add some sugar for generated reference-type-list properties When compiling a reference type list with qmltc into a QQmlListProperty, also generate helper methods to make the manipulation of those lists by the user easier in c++. For a list myList, generate the methods myListAt(), myListAppend(), ... as shown in the Birthdayparty example. Also add some documentation about the ownership of the arguments, and tests to see if the list can be accessed from C++. Task-number: QTBUG-107570 Change-Id: Iec0041015311639ead39660fdccf147749566592 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-10-17 13:27:12 +00:00
at.name = u"%1At"_s.arg(data.read);
at.parameterList.emplaceBack(u"qsizetype"_s, u"position"_s, QString());
at.body << u"auto q_qmltc_localList = %1;"_s.arg(variableName);
at.body << u"auto result = q_qmltc_localList.at(std::addressof(q_qmltc_localList), position);"_s;
at.body << u"return result;"_s;
at.userVisible = true;
current.functions.emplaceBack(at);
}
// generate clear() sugar for users
{
QmltcMethod clear{};
clear.comments.emplaceBack(u"\\brief Clear %1."_s.arg(data.read));
clear.returnType = u"void"_s;
clear.name = u"%1Clear"_s.arg(data.read);
clear.body << u"auto q_qmltc_localList = %1;"_s.arg(variableName);
clear.body << u"q_qmltc_localList.clear(std::addressof(q_qmltc_localList));"_s;
// clear.body << u"Q_EMIT %1();"_s.arg(data.notify); // uncomment this when QTBUG-106587 is
// resolved
clear.userVisible = true;
current.functions.emplaceBack(clear);
}
// generate replace() sugar for users
{
QmltcMethod replace{};
replace.comments.emplaceBack(u"\\brief Replace an element in %1."_s.arg(data.read));
replace.comments << ownershipWarning;
replace.returnType = u"void"_s;
replace.name = u"%1Replace"_s.arg(data.read);
replace.parameterList.emplaceBack(u"qsizetype"_s, u"position"_s, QString());
QmlCompiler: Rename sequences' "valueType" to "elementType" "valueType" is ambiguous. The prevailing meaning is a type that's passed by value in QML. We mean the type of the list contents (or elements) here. Change-Id: Iaf4c0efe272dc6ec7511d2361e7e5ce475936fba Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2025-08-25 09:00:35 +00:00
replace.parameterList.emplaceBack(elementType, u"element"_s,
qmltc: Add some sugar for generated reference-type-list properties When compiling a reference type list with qmltc into a QQmlListProperty, also generate helper methods to make the manipulation of those lists by the user easier in c++. For a list myList, generate the methods myListAt(), myListAppend(), ... as shown in the Birthdayparty example. Also add some documentation about the ownership of the arguments, and tests to see if the list can be accessed from C++. Task-number: QTBUG-107570 Change-Id: Iec0041015311639ead39660fdccf147749566592 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-10-17 13:27:12 +00:00
QString());
replace.body << u"auto q_qmltc_localList = %1;"_s.arg(variableName);
replace.body
<< u"q_qmltc_localList.replace(std::addressof(q_qmltc_localList), position, element);"_s;
// replace.body << u"Q_EMIT %1();"_s.arg(data.notify); // uncomment this when QTBUG-106587
// is resolved
replace.userVisible = true;
current.functions.emplaceBack(replace);
}
// generate removeLast() sugar for users
{
QmltcMethod removeLast{};
removeLast.comments.emplaceBack(u"\\brief Remove the last element in %1."_s.arg(data.read));
removeLast.returnType = u"void"_s;
removeLast.name = u"%1RemoveLast"_s.arg(data.read);
removeLast.body << u"auto q_qmltc_localList = %1;"_s.arg(variableName);
removeLast.body << u"q_qmltc_localList.removeLast(std::addressof(q_qmltc_localList));"_s;
// removeLast.body << u"Q_EMIT %1();"_s.arg(data.notify); // uncomment this when
// QTBUG-106587 is resolved
removeLast.userVisible = true;
current.functions.emplaceBack(removeLast);
}
}
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
void QmltcCompiler::compileProperty(QmltcType &current, const QQmlJSMetaProperty &p,
const QQmlJSScope::ConstPtr &owner)
{
Q_ASSERT(!p.isAlias()); // will be handled separately
Q_ASSERT(p.type());
const QString name = p.propertyName();
const QString variableName = u"m_" + name;
const QString underlyingType = getUnderlyingType(p);
Support value type lists in qmltc Generate list of values in qmltc when possible, by using QList<T> instead of QQmlListProperty<T>, e.g., when T is an int or a QColor.. Fixes: QTBUG-100313 Change-Id: Ifd84cbb550437854fb156a295435240cef446e61 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-06-29 15:21:49 +00:00
if (qIsReferenceTypeList(p)) {
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
const QString storageName = variableName + u"_storage";
QmlCompiler: Allow lists as arguments to methods Since lists are allowed as property types, you should be able to pass them as arguments to methods, too. For now we only handle QML-defined methods, implemented by adding JavaScript functions to your QML elements. The usual type coercion rules apply if you pass JavaScript arrays to such methods. That is, it usually works. We now resolve properties with the "list" flag to their actual types (QQmlListProperty or QList) already when populating the QQmlJSScope, and store the list types as members of QQmlJSScope rather than as a special map in QQmlJSTypeResolver. This allows us to do the same to lists passed as arguments and simplifies some of the type analysis. Fixes: QTBUG-107171 Change-Id: Idf71ccdc1d59f472c17084a36b5d7879c4d959c0 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-10-19 12:35:24 +00:00
current.variables.emplaceBack(
QmlCompiler: Rename sequences' "valueType" to "elementType" "valueType" is ambiguous. The prevailing meaning is a type that's passed by value in QML. We mean the type of the list contents (or elements) here. Change-Id: Iaf4c0efe272dc6ec7511d2361e7e5ce475936fba Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2025-08-25 09:00:35 +00:00
u"QList<" + p.type()->elementType()->internalName() + u"*>", storageName,
QmlCompiler: Allow lists as arguments to methods Since lists are allowed as property types, you should be able to pass them as arguments to methods, too. For now we only handle QML-defined methods, implemented by adding JavaScript functions to your QML elements. The usual type coercion rules apply if you pass JavaScript arrays to such methods. That is, it usually works. We now resolve properties with the "list" flag to their actual types (QQmlListProperty or QList) already when populating the QQmlJSScope, and store the list types as members of QQmlJSScope rather than as a special map in QQmlJSTypeResolver. This allows us to do the same to lists passed as arguments and simplifies some of the type analysis. Fixes: QTBUG-107171 Change-Id: Idf71ccdc1d59f472c17084a36b5d7879c4d959c0 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-10-19 12:35:24 +00:00
QString());
Remove qmltc prototype code (2/N) - Migrate to the newer output ir classes (with adjustments) - Deduplicate code writer and remove now-unused output helpers from the prototype version - Remove old output ir Change-Id: Ie7fe5e6d47e18477c65af02cabd89a890628442c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-03 13:03:58 +00:00
current.baselineCtor.initializerList.emplaceBack(variableName + u"(" + underlyingType
+ u"(this, std::addressof(" + storageName
+ u")))");
qmltc: Add some sugar for generated reference-type-list properties When compiling a reference type list with qmltc into a QQmlListProperty, also generate helper methods to make the manipulation of those lists by the user easier in c++. For a list myList, generate the methods myListAt(), myListAppend(), ... as shown in the Birthdayparty example. Also add some documentation about the ownership of the arguments, and tests to see if the list can be accessed from C++. Task-number: QTBUG-107570 Change-Id: Iec0041015311639ead39660fdccf147749566592 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-10-17 13:27:12 +00:00
compileExtraListMethods(current, p);
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
}
// along with property, also add relevant moc code, so that we can use the
// property in Qt/QML contexts
QStringList mocPieces;
mocPieces.reserve(10);
mocPieces << underlyingType << name;
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
QmltcPropertyData compilationData(p);
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
// 1. add setter and getter
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
// If p.isList(), it's a QQmlListProperty. Then you can write the underlying list through
// the QQmlListProperty object retrieved with the getter. Setting it would make no sense.
qmltc: Add READ before WRITE in generated Q_PROPERTYs We currently have two orderings for the READ and WRITE elements of the macro depending on whether we compile a property or an alias. Make them uniform by having READ before WRITE in both cases. Change-Id: I1dd308c921b8948347029c603bc3bca2be87abda Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2024-11-28 14:35:18 +00:00
QmltcMethod getter{};
getter.returnType = underlyingType;
getter.name = compilationData.read;
getter.body << u"return " + variableName + u".value();";
getter.userVisible = true;
current.functions.emplaceBack(getter);
mocPieces << u"READ"_s << getter.name;
Support value type lists in qmltc Generate list of values in qmltc when possible, by using QList<T> instead of QQmlListProperty<T>, e.g., when T is an int or a QColor.. Fixes: QTBUG-100313 Change-Id: Ifd84cbb550437854fb156a295435240cef446e61 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-06-29 15:21:49 +00:00
if (p.isWritable() && !qIsReferenceTypeList(p)) {
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
QmltcMethod setter {};
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
setter.returnType = u"void"_s;
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
setter.name = compilationData.write;
// QmltcVariable
Unify common logic around QQmlJSScope and friends We have many things duplicated all over the place Pick-to: 6.3 Change-Id: If929a5d683153781f6db630312240bf9c24ec777 Reviewed-by: Fawzi Mohamed <fawzi.mohamed@qt.io>
2021-12-17 14:52:17 +00:00
setter.parameterList.emplaceBack(QQmlJSUtils::constRefify(underlyingType), name + u"_",
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
u""_s);
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
setter.body << variableName + u".setValue(" + name + u"_);";
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
setter.body << u"Q_EMIT " + compilationData.notify + u"();";
setter.userVisible = true;
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
current.functions.emplaceBack(setter);
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
mocPieces << u"WRITE"_s << setter.name;
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
}
// 2. add bindable
Support value type lists in qmltc Generate list of values in qmltc when possible, by using QList<T> instead of QQmlListProperty<T>, e.g., when T is an int or a QColor.. Fixes: QTBUG-100313 Change-Id: Ifd84cbb550437854fb156a295435240cef446e61 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-06-29 15:21:49 +00:00
if (!qIsReferenceTypeList(p)) {
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
QmltcMethod bindable {};
bindable.returnType = u"QBindable<" + underlyingType + u">";
bindable.name = compilationData.bindable;
bindable.body << u"return QBindable<" + underlyingType + u">(std::addressof(" + variableName
+ u"));";
bindable.userVisible = true;
current.functions.emplaceBack(bindable);
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
mocPieces << u"BINDABLE"_s << bindable.name;
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
}
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
// 3. add/check notify (actually, this is already done inside QmltcVisitor)
if (owner->isPropertyRequired(name))
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
mocPieces << u"REQUIRED"_s;
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
// 4. add moc entry
// e.g. Q_PROPERTY(QString p READ getP WRITE setP BINDABLE bindableP)
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
current.mocCode << u"Q_PROPERTY(" + mocPieces.join(u" "_s) + u")";
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
// 5. add extra moc entry if this property is marked default
if (name == owner->defaultPropertyName())
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
current.mocCode << u"Q_CLASSINFO(\"DefaultProperty\", \"%1\")"_s.arg(name);
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
// structure: (C++ type name, name, C++ class name, C++ signal name)
qmltc: Migrate to new object creation/querying mechanism Serves two things: a) Provides faster/more correct object creation model (long-term) b) Eliminates (more of) prototype's code generation (short-term) The whole object querying now works implicitly through the std::array<QObject *> that QQmltcObjectCreationBase provides. The creation logic is still rather recursive with regards to QML base types processing - unfortunately, we cannot simplify this part now as qmltc requires deeper introspection into the imported types (this in turn requires fiddling with QQmlJSTypeReader and QDeferredFactory<QQmlJSScope>::create()) Since we now use the new object creation pattern, prototype/codegenerator no longer needs high-level compilation methods. So replace prototype's code accordingly with qmltccompiler bits. We can also de-duplicate enum and property compilation (aliases are not touched for simplification) from prototype. Methods and bindings have to rely on prototype and QmlIR at present, their compilation is moved more-or-less unchanged Task-number: QTBUG-84368 Change-Id: I584ceb8f2e3c9f3f79530b02d1c88a4f6c2d06c9 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-19 12:04:05 +00:00
current.properties.emplaceBack(underlyingType, variableName, current.cppType,
compilationData.notify);
qmltc: Compile QML properties into C++ Update the QQmlJSScope::insertPropertyIdentifier along the way since it doesn't mark a signal method as a signal Task-number: QTBUG-84368 Change-Id: I4594520e46e2d85cc7fa82357d9cc1c62c66b732 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-10-29 09:56:25 +00:00
}
qmltc: add some internal documentation add some documentation to qmltc's internal behavior that is not self-documenting enough. Change-Id: I131ee875944e294e0472519573ace4058f4f1821 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:41 +00:00
/*!
* \internal
*
* Models one step of the alias resolution. If the current alias to be resolved
* points to \c {x.y.z} and that \c {x.y} is already resolved, then this struct
* contains the information on how to obtain the \c {z} part from \c {x.y}.
*/
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
struct AliasResolutionFrame
{
qmltc: add some internal documentation add some documentation to qmltc's internal behavior that is not self-documenting enough. Change-Id: I131ee875944e294e0472519573ace4058f4f1821 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:41 +00:00
/*!
* \internal
*
* Placeholder for the current resolved state. It is replaced later with
* the result from previous resolutions from the \c QStack<AliasResolutionFrame>.
*
* \sa unpackFrames()
*/
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
static QString inVar;
qmltc: add some internal documentation add some documentation to qmltc's internal behavior that is not self-documenting enough. Change-Id: I131ee875944e294e0472519573ace4058f4f1821 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:41 +00:00
/*!
* \internal
*
* Steps to access this value as a list of C++ statements, to be used in
* conjunction with \c {epilogue}.
*/
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
QStringList prologue;
qmltc: add some internal documentation add some documentation to qmltc's internal behavior that is not self-documenting enough. Change-Id: I131ee875944e294e0472519573ace4058f4f1821 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:41 +00:00
/*!
* \internal
*
* Steps to finish the statements of the \c prologue (e.g. closing brackets).
*/
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
QStringList epilogue;
qmltc: add some internal documentation add some documentation to qmltc's internal behavior that is not self-documenting enough. Change-Id: I131ee875944e294e0472519573ace4058f4f1821 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:41 +00:00
/*!
* \internal
*
* Instructions on how to write the property, after it was loaded with the
* instructions from \c prologue. Has to happen before \c epilogue.
*/
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
QStringList epilogueForWrite;
qmltc: add some internal documentation add some documentation to qmltc's internal behavior that is not self-documenting enough. Change-Id: I131ee875944e294e0472519573ace4058f4f1821 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:41 +00:00
/*!
* \internal
*
* Name of the variable holding the result of this resolution step, to be
* used in the following resolution steps.
*/
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
QString outVar;
};
// special string replaced by outVar of the previous frame
QString AliasResolutionFrame::inVar = QStringLiteral("__QMLTC_ALIAS_FRAME_INPUT_VAR__");
qmltc: add some internal documentation add some documentation to qmltc's internal behavior that is not self-documenting enough. Change-Id: I131ee875944e294e0472519573ace4058f4f1821 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:41 +00:00
/*!
* \internal
*
* Process the frames by replacing the placeholder \c invar
* used in \c epilogueForWrite and \c prologue with the result
* obtained from the previous frame.
*/
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
static void unpackFrames(QStack<AliasResolutionFrame> &frames)
{
if (frames.size() < 2)
return;
// assume first frame is fine
auto prev = frames.begin();
for (auto it = std::next(prev); it != frames.end(); ++it, ++prev) {
for (QString &line : it->prologue)
line.replace(AliasResolutionFrame::inVar, prev->outVar);
for (QString &line : it->epilogueForWrite)
line.replace(AliasResolutionFrame::inVar, prev->outVar);
it->outVar.replace(AliasResolutionFrame::inVar, prev->outVar);
}
}
template<typename Projection>
static QStringList joinFrames(const QStack<AliasResolutionFrame> &frames, Projection project)
{
QStringList joined;
for (const AliasResolutionFrame &frame : frames)
joined += project(frame);
return joined;
}
void QmltcCompiler::compileAlias(QmltcType &current, const QQmlJSMetaProperty &alias,
const QQmlJSScope::ConstPtr &owner)
{
const QString aliasName = alias.propertyName();
Q_ASSERT(!aliasName.isEmpty());
QStringList aliasExprBits = alias.aliasExpression().split(u'.');
Q_ASSERT(!aliasExprBits.isEmpty());
QStack<AliasResolutionFrame> frames;
QQmlJSUtils::AliasResolutionVisitor aliasVisitor;
qsizetype i = 0;
aliasVisitor.reset = [&]() {
frames.clear();
i = 0; // we use it in property processing
// first frame is a dummy one:
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
frames.push(
AliasResolutionFrame { QStringList(), QStringList(), QStringList(), u"this"_s });
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
};
aliasVisitor.processResolvedId = [&](const QQmlJSScope::ConstPtr &type) {
Q_ASSERT(type);
if (owner != type) { // cannot start at `this`, need to fetch object through context
const int id = m_visitor->runtimeId(type);
Q_ASSERT(id >= 0); // since the type is found by id, it must have an id
AliasResolutionFrame queryIdFrame {};
Remember QML document context in each qmltc-generated object There is an apparent problem in certain cases where using outer context to fetch ids is invalid: the outer context is the *outermost* context, meaning that if a type has a derived type in another QML document, the derived type would place its own context as a QQmlData::outerContext As a simpler solution, just remember the document's context in all the objects within this document. This automatically works in derived types since they appear in other documents with separate contexts Pick-to: 6.4 Fixes: QTBUG-103956 Change-Id: I29420ff4962b485502d87b2d2ac2f89b9e0f5736 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Sami Shalayel <sami.shalayel@qt.io>
2022-06-08 10:33:14 +00:00
Q_ASSERT(frames.top().outVar == u"this"_s); // so inVar would be "this" as well
queryIdFrame.prologue << u"auto context = %1::q_qmltc_thisContext;"_s.arg(
owner->internalName());
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
// doing the above allows us to lookup id object by index (fast)
queryIdFrame.outVar = u"alias_objectById_" + aliasExprBits.front(); // unique enough
qmltc: Make explicit component ids accessible during object creation Explicit components could be accessed by id like regular objects. Make this work in qmltc by revisiting the object creation procedure - store explicit components along with pure QML types in QQmltcObjectCreationBase: xxxxxxxx x'x'x'x'x'|yyyyy... ^ ^ ^ pure explicit types from base class types components As a drive by, fix unset required property in one test file and add a bunch of other test files to the initTestCase() check Pick-to: 6.4 Change-Id: Ibdaa430d692c81101853f51dae1da462a57a9980 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-26 12:32:23 +00:00
const QString cppType = (m_visitor->qmlComponentIndex(type) == -1)
? type->internalName()
: u"QQmlComponent"_s;
queryIdFrame.prologue << u"auto " + queryIdFrame.outVar + u" = static_cast<" + cppType
+ u"*>(context->idValue(" + QString::number(id) + u"));";
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
queryIdFrame.prologue << u"Q_ASSERT(" + queryIdFrame.outVar + u");";
frames.push(queryIdFrame);
}
};
aliasVisitor.processResolvedProperty = [&](const QQmlJSMetaProperty &p,
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
const QQmlJSScope::ConstPtr &owner) {
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
AliasResolutionFrame queryPropertyFrame {};
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
auto [extensionPrologue, extensionAccessor, extensionEpilogue] =
QmltcCodeGenerator::wrap_extensionType(
owner, p,
QmltcCodeGenerator::wrap_privateClass(AliasResolutionFrame::inVar, p));
QString inVar = extensionAccessor;
queryPropertyFrame.prologue += extensionPrologue;
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
if (p.type()->accessSemantics() == QQmlJSScope::AccessSemantics::Value) {
// we need to read the property to a local variable and then
// write the updated value once the actual operation is done
const QString aliasVar = u"alias_" + QString::number(i); // should be fairly unique
++i;
queryPropertyFrame.prologue
<< u"auto " + aliasVar + u" = " + inVar + u"->" + p.read() + u"();";
queryPropertyFrame.epilogueForWrite
<< inVar + u"->" + p.write() + u"(" + aliasVar + u");";
// NB: since accessor becomes a value type, wrap it into an
// addressof operator so that we could access it as a pointer
inVar = QmltcCodeGenerator::wrap_addressof(aliasVar); // reset
} else {
inVar += u"->" + p.read() + u"()"; // update
}
queryPropertyFrame.outVar = inVar;
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
queryPropertyFrame.epilogue += extensionEpilogue;
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
frames.push(queryPropertyFrame);
};
QQmlJSUtils::ResolvedAlias result =
QQmlJSUtils::resolveAlias(m_typeResolver, alias, owner, aliasVisitor);
Q_ASSERT(result.kind != QQmlJSUtils::AliasTarget_Invalid);
unpackFrames(frames);
if (result.kind == QQmlJSUtils::AliasTarget_Property) {
// we don't need the last frame here
frames.pop();
// instead, add a custom frame
AliasResolutionFrame customFinalFrame {};
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
auto [extensionPrologue, extensionAccessor, extensionEpilogue] =
QmltcCodeGenerator::wrap_extensionType(
result.owner, result.property,
QmltcCodeGenerator::wrap_privateClass(frames.top().outVar,
result.property));
customFinalFrame.prologue = extensionPrologue;
customFinalFrame.outVar = extensionAccessor;
customFinalFrame.epilogue = extensionEpilogue;
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
frames.push(customFinalFrame);
}
const QString latestAccessor = frames.top().outVar;
const QStringList prologue =
joinFrames(frames, [](const AliasResolutionFrame &frame) { return frame.prologue; });
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
const QStringList epilogue =
joinFrames(frames, [](const AliasResolutionFrame &frame) { return frame.epilogue; });
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
const QString underlyingType = (result.kind == QQmlJSUtils::AliasTarget_Property)
? getUnderlyingType(result.property)
: result.owner->internalName() + u" *";
QStringList mocLines;
mocLines.reserve(10);
mocLines << underlyingType << aliasName;
QmltcPropertyData compilationData(aliasName);
// 1. add setter and getter
QmltcMethod getter {};
getter.returnType = underlyingType;
getter.name = compilationData.read;
getter.body += prologue;
qmltc: Ensure properties with MEMBER can be read and written Pick-to: 6.4 Task-number: QTBUG-91956 Change-Id: I980089ed7e4991de7bf7429722caf7351d9e79b4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-06-23 07:48:04 +00:00
if (result.kind == QQmlJSUtils::AliasTarget_Property) {
qmltc: Acknowledge BINDABLE-only properties Task-number: QTBUG-91956 Change-Id: I4c34ccd9d6d5cf4c6a6c1b54e67374515e67861a Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-25 10:58:15 +00:00
if (QString read = result.property.read(); !read.isEmpty()
&& !QQmlJSUtils::bindablePropertyHasDefaultAccessor(
result.property, QQmlJSUtils::PropertyAccessor_Read)) {
qmltc: Ensure properties with MEMBER can be read and written Pick-to: 6.4 Task-number: QTBUG-91956 Change-Id: I980089ed7e4991de7bf7429722caf7351d9e79b4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-06-23 07:48:04 +00:00
getter.body << u"return %1->%2();"_s.arg(latestAccessor, read);
} else { // use QObject::property() as a fallback when read method is unknown
getter.body << u"return qvariant_cast<%1>(%2->property(\"%3\"));"_s.arg(
underlyingType, latestAccessor, result.property.propertyName());
}
} else { // AliasTarget_Object
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
getter.body << u"return " + latestAccessor + u";";
qmltc: Ensure properties with MEMBER can be read and written Pick-to: 6.4 Task-number: QTBUG-91956 Change-Id: I980089ed7e4991de7bf7429722caf7351d9e79b4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-06-23 07:48:04 +00:00
}
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
getter.body += epilogue;
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
getter.userVisible = true;
current.functions.emplaceBack(getter);
mocLines << u"READ"_s << getter.name;
qmltc: Ensure properties with MEMBER can be read and written Pick-to: 6.4 Task-number: QTBUG-91956 Change-Id: I980089ed7e4991de7bf7429722caf7351d9e79b4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-06-23 07:48:04 +00:00
if (result.property.isWritable()) {
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
Q_ASSERT(result.kind == QQmlJSUtils::AliasTarget_Property); // property is invalid otherwise
QmltcMethod setter {};
setter.returnType = u"void"_s;
setter.name = compilationData.write;
qmltc: Ensure properties with MEMBER can be read and written Pick-to: 6.4 Task-number: QTBUG-91956 Change-Id: I980089ed7e4991de7bf7429722caf7351d9e79b4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-06-23 07:48:04 +00:00
const QString setName = result.property.write();
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
QList<QQmlJSMetaMethod> methods = result.owner->methods(setName);
if (methods.isEmpty()) { // when we are compiling the property as well
// QmltcVariable
setter.parameterList.emplaceBack(QQmlJSUtils::constRefify(underlyingType),
aliasName + u"_", u""_s);
} else {
QQmlJSMetaParameter: Encapsulate parameter information Previously, there were four lists that contained each one entry for each parameter. There was one list responsible for the names, types, type names and const-qualifiers but this was quite bothersome to use (e.g. they not always had the same length). This commit introduces QQmlJSMetaParameter to encapsulate all the information required when manipulating parameters. This reduce the 4 lists to one, making parameters easier to handle and QQmlJSMetaMethod easier to read. This is a purely refactoring change, no new functionality was added. Task-number: QTBUG-107625 Change-Id: Ia41b823c9e6294ee26e828071b802cac6b4058ce Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-11-10 10:38:51 +00:00
setter.parameterList = compileMethodParameters(methods.at(0).parameters(),
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
/* allow unnamed = */ true);
}
setter.body += prologue;
QStringList parameterNames;
parameterNames.reserve(setter.parameterList.size());
std::transform(setter.parameterList.cbegin(), setter.parameterList.cend(),
std::back_inserter(parameterNames),
[](const QmltcVariable &x) { return x.name; });
QString commaSeparatedParameterNames = parameterNames.join(u", "_s);
qmltc: Acknowledge BINDABLE-only properties Task-number: QTBUG-91956 Change-Id: I4c34ccd9d6d5cf4c6a6c1b54e67374515e67861a Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-25 10:58:15 +00:00
if (!setName.isEmpty()
&& !QQmlJSUtils::bindablePropertyHasDefaultAccessor(
result.property, QQmlJSUtils::PropertyAccessor_Write)) {
qmltc: Ensure properties with MEMBER can be read and written Pick-to: 6.4 Task-number: QTBUG-91956 Change-Id: I980089ed7e4991de7bf7429722caf7351d9e79b4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-06-23 07:48:04 +00:00
setter.body << u"%1->%2(%3);"_s.arg(latestAccessor, setName,
commaSeparatedParameterNames);
} else { // use QObject::setProperty() as fallback when write method is unknown
Q_ASSERT(parameterNames.size() == 1);
const QString variantName = u"var_" + aliasName; // fairly unique
setter.body << u"QVariant %1;"_s.arg(variantName);
setter.body << u"%1.setValue(%2);"_s.arg(variantName, commaSeparatedParameterNames);
setter.body << u"%1->setProperty(\"%2\", std::move(%3));"_s.arg(
latestAccessor, result.property.propertyName(), variantName);
}
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
setter.body += joinFrames(
frames, [](const AliasResolutionFrame &frame) { return frame.epilogueForWrite; });
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
setter.body += epilogue; // NB: *after* epilogueForWrite - see prologue construction
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
setter.userVisible = true;
current.functions.emplaceBack(setter);
mocLines << u"WRITE"_s << setter.name;
}
// 2. add bindable
if (QString bindableName = result.property.bindable(); !bindableName.isEmpty()) {
Q_ASSERT(result.kind == QQmlJSUtils::AliasTarget_Property); // property is invalid otherwise
QmltcMethod bindable {};
bindable.returnType = u"QBindable<" + underlyingType + u">";
bindable.name = compilationData.bindable;
bindable.body += prologue;
bindable.body << u"return " + latestAccessor + u"->" + bindableName + u"()" + u";";
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
bindable.body += epilogue;
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
bindable.userVisible = true;
current.functions.emplaceBack(bindable);
mocLines << u"BINDABLE"_s << bindable.name;
}
qmltc: test alias on properties with attributes Add tests to qmltc to see if it behaves well for aliases to different kinds of properties, and compares if the engine shares the same behavior. Same for the attributes in the QMetaProperties. Changes: * add some more MOC information to aliases ** always add NOTIFY to aliases (like the engine does) ** always set DESIGNABLE to false for aliases (like the engine does) ** always set CONSTANT to false for aliases (like the engine does) ** always set STORED to false for aliases (like the engine does) Test if: * default aliases works when compiled via qmltc * attributes of aliases are set correctly in QMetaProperty and compare it to the attributes of the QMetaProperty obtained from the engine. * aliases can read/written/reset/notified Fixes: QTBUG-105708 Change-Id: I66b9c43c8c8de3dbd2b33d5ce15cd42ffb377ce7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:03 +00:00
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
// 3. add notify - which is pretty special
qmltc: test alias on properties with attributes Add tests to qmltc to see if it behaves well for aliases to different kinds of properties, and compares if the engine shares the same behavior. Same for the attributes in the QMetaProperties. Changes: * add some more MOC information to aliases ** always add NOTIFY to aliases (like the engine does) ** always set DESIGNABLE to false for aliases (like the engine does) ** always set CONSTANT to false for aliases (like the engine does) ** always set STORED to false for aliases (like the engine does) Test if: * default aliases works when compiled via qmltc * attributes of aliases are set correctly in QMetaProperty and compare it to the attributes of the QMetaProperty obtained from the engine. * aliases can read/written/reset/notified Fixes: QTBUG-105708 Change-Id: I66b9c43c8c8de3dbd2b33d5ce15cd42ffb377ce7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:03 +00:00
// step 1: generate the moc instructions
// mimic the engines behavior: do it even if the notify will never be emitted
if (const QString aliasNotifyName = alias.notify(); !aliasNotifyName.isEmpty()) {
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
Q_ASSERT(result.kind == QQmlJSUtils::AliasTarget_Property); // property is invalid otherwise
qmltc: test alias on properties with attributes Add tests to qmltc to see if it behaves well for aliases to different kinds of properties, and compares if the engine shares the same behavior. Same for the attributes in the QMetaProperties. Changes: * add some more MOC information to aliases ** always add NOTIFY to aliases (like the engine does) ** always set DESIGNABLE to false for aliases (like the engine does) ** always set CONSTANT to false for aliases (like the engine does) ** always set STORED to false for aliases (like the engine does) Test if: * default aliases works when compiled via qmltc * attributes of aliases are set correctly in QMetaProperty and compare it to the attributes of the QMetaProperty obtained from the engine. * aliases can read/written/reset/notified Fixes: QTBUG-105708 Change-Id: I66b9c43c8c8de3dbd2b33d5ce15cd42ffb377ce7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:03 +00:00
mocLines << u"NOTIFY"_s << aliasNotifyName;
}
// step 2: connect the notifier to the aliased property notifier, if this latter exists
// otherwise, mimic the engines behavior and generate a useless notify
if (const QString notifyName = result.property.notify(); !notifyName.isEmpty()) {
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
auto notifyFrames = frames;
notifyFrames.pop(); // we don't need the last frame at all in this case
const QStringList notifyPrologue = joinFrames(
frames, [](const AliasResolutionFrame &frame) { return frame.prologue; });
const QStringList notifyEpilogue = joinFrames(
frames, [](const AliasResolutionFrame &frame) { return frame.epilogue; });
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
// notify is very special
current.endInit.body << u"{ // alias notify connection:"_s;
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
current.endInit.body += notifyPrologue;
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
// TODO: use non-private accessor since signals must exist on the public
// type, not on the private one -- otherwise, you can't connect to a
// private property signal in C++ and so it is useless (hence, use
// public type)
qmltc: Make explicit component ids accessible during object creation Explicit components could be accessed by id like regular objects. Make this work in qmltc by revisiting the object creation procedure - store explicit components along with pure QML types in QQmltcObjectCreationBase: xxxxxxxx x'x'x'x'x'|yyyyy... ^ ^ ^ pure explicit types from base class types components As a drive by, fix unset required property in one test file and add a bunch of other test files to the initTestCase() check Pick-to: 6.4 Change-Id: Ibdaa430d692c81101853f51dae1da462a57a9980 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-26 12:32:23 +00:00
const QString cppType = (m_visitor->qmlComponentIndex(result.owner) == -1)
? result.owner->internalName()
: u"QQmlComponent"_s;
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
const QString latestAccessorNonPrivate = notifyFrames.top().outVar;
qmltc: Make explicit component ids accessible during object creation Explicit components could be accessed by id like regular objects. Make this work in qmltc by revisiting the object creation procedure - store explicit components along with pure QML types in QQmltcObjectCreationBase: xxxxxxxx x'x'x'x'x'|yyyyy... ^ ^ ^ pure explicit types from base class types components As a drive by, fix unset required property in one test file and add a bunch of other test files to the initTestCase() check Pick-to: 6.4 Change-Id: Ibdaa430d692c81101853f51dae1da462a57a9980 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-26 12:32:23 +00:00
current.endInit.body << u"QObject::connect(" + latestAccessorNonPrivate + u", &" + cppType
+ u"::" + notifyName + u", this, &" + current.cppType + u"::"
+ compilationData.notify + u");";
Address extension types in qmltc Whenever working with properties (reading, writing, aliasing, etc.) of the type that has extensions, prefer the same-named properties from extension objects over type-owned properties (this is the internal QML mechanism) To achieve that, we need to query the extension object: * for Q_GADGETs use a dummy model of assuming we can cast the object to the extension type and use that * for Q_OBJECTs use a qmlExtendedObject() with additional logic of figuring out which extension should be picked in each specific case Create QQmlProxyMetaObject via a custom dynamic meta object API for qmltc-compiled objects that are derived from base types with extensions Task-number: QTBUG-91956 Change-Id: I5e783768ae2abdb9dddf894de7e79960244352bd Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-04-28 09:03:09 +00:00
current.endInit.body += notifyEpilogue;
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
current.endInit.body << u"}"_s;
}
qmltc: test alias on properties with attributes Add tests to qmltc to see if it behaves well for aliases to different kinds of properties, and compares if the engine shares the same behavior. Same for the attributes in the QMetaProperties. Changes: * add some more MOC information to aliases ** always add NOTIFY to aliases (like the engine does) ** always set DESIGNABLE to false for aliases (like the engine does) ** always set CONSTANT to false for aliases (like the engine does) ** always set STORED to false for aliases (like the engine does) Test if: * default aliases works when compiled via qmltc * attributes of aliases are set correctly in QMetaProperty and compare it to the attributes of the QMetaProperty obtained from the engine. * aliases can read/written/reset/notified Fixes: QTBUG-105708 Change-Id: I66b9c43c8c8de3dbd2b33d5ce15cd42ffb377ce7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:03 +00:00
qmltc: Support CONSTANT and RESET property attributes in aliases As a drive by, propagate CONSTANT attribute through the .qmltypes file and qmlcompiler library Task-number: QTBUG-91956 Change-Id: I5802fa29ddedcdadae3e505efca0c4fb4d6b2593 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-07-29 08:27:50 +00:00
if (QString resetName = result.property.reset(); !resetName.isEmpty()) {
Q_ASSERT(result.kind == QQmlJSUtils::AliasTarget_Property); // property is invalid otherwise
QmltcMethod reset {};
reset.returnType = u"void"_s;
reset.name = compilationData.reset;
reset.body += prologue;
reset.body << latestAccessor + u"->" + resetName + u"()" + u";";
reset.body += epilogue;
reset.userVisible = true;
current.functions.emplaceBack(reset);
mocLines << u"RESET"_s << reset.name;
}
qmltc: test alias on properties with attributes Add tests to qmltc to see if it behaves well for aliases to different kinds of properties, and compares if the engine shares the same behavior. Same for the attributes in the QMetaProperties. Changes: * add some more MOC information to aliases ** always add NOTIFY to aliases (like the engine does) ** always set DESIGNABLE to false for aliases (like the engine does) ** always set CONSTANT to false for aliases (like the engine does) ** always set STORED to false for aliases (like the engine does) Test if: * default aliases works when compiled via qmltc * attributes of aliases are set correctly in QMetaProperty and compare it to the attributes of the QMetaProperty obtained from the engine. * aliases can read/written/reset/notified Fixes: QTBUG-105708 Change-Id: I66b9c43c8c8de3dbd2b33d5ce15cd42ffb377ce7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-22 09:13:03 +00:00
// mimic the engines behavior: aliases are never constants
// mocLines << u"CONSTANT"_s;
// mimic the engines behavior: aliases are never stored
mocLines << u"STORED"_s << u"false"_s;
// mimic the engines behavior: aliases are never designable
mocLines << u"DESIGNABLE"_s << u"false"_s;
qmltc: Move alias compilation to qqmltccompiler Introduce an alias resolution procedure to query the origin property and its owner for a given alias Add alias compilation to the "proper" qmltc code and remove the equivalent one from the prototype Change-Id: I55bc1e3e6206b4cfce259526d1bc2813e8ea7cfb Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-04-22 10:51:41 +00:00
// 4. add moc entry
// Q_PROPERTY(QString text READ text WRITE setText BINDABLE bindableText NOTIFY textChanged)
current.mocCode << u"Q_PROPERTY(" + mocLines.join(u" "_s) + u")";
// 5. add extra moc entry if this alias is default one
if (aliasName == owner->defaultPropertyName()) {
// Q_CLASSINFO("DefaultProperty", propertyName)
current.mocCode << u"Q_CLASSINFO(\"DefaultProperty\", \"%1\")"_s.arg(aliasName);
}
}
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
static QString generate_callCompilationUnit(const QString &urlMethodName)
{
return u"QQmlEnginePrivate::get(engine)->compilationUnitFromUrl(%1())"_s.arg(urlMethodName);
}
qmltc: translation binding support Implement and test support for translation bindings in qmltc: * qsTr() * QT_TR_NOOP() * qsTrId() * QT_TRID_NOOP() Not compiled by qmltc, but instead interpreted as script bindings: * combinations like qsTr(qsTr()) * qsTranslate() (as in qmlsc) * QT_TRANSLATE_NOOP() (as in qmlsc) Add the *.qm files directly to the resources as qt_add_translations() is not available from qtdeclarative (the cmake function lives in qttools that depends on qtdeclarative). Fixes: QTBUG-104637 Task-Id: QTBUG-105346 Change-Id: Ia9433c2bcef01f3486358d963059d9779c67708c Reviewed-by: Sami Shalayel <sami.shalayel@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-02 14:20:07 +00:00
static std::pair<QQmlJSMetaProperty, int> getMetaPropertyIndex(const QQmlJSScope::ConstPtr &scope,
const QString &propertyName);
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
/*!
* \internal
* Helper method used to keep compileBindingByType() readable.
*/
void QmltcCompiler::compileObjectBinding(QmltcType &current,
const QQmlJSMetaPropertyBinding &binding,
const QQmlJSScope::ConstPtr &type,
const BindingAccessorData &accessor)
{
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
Q_ASSERT(binding.bindingType() == QQmlSA::BindingType::Object);
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
const QString &propertyName = binding.propertyName();
const QQmlJSMetaProperty property = type->property(propertyName);
QQmlJSScope::ConstPtr propertyType = property.type();
// NB: object is compiled with compileType(), here just need to use it
auto object = binding.objectType();
// Note: despite a binding being set for `accessor`, we use "this" as a
// parent of a created object. Both attached and grouped properties are
// parented by "this", so lifetime-wise we should be fine
const QString qobjectParent = u"this"_s;
if (!propertyType) {
recordError(binding.sourceLocation(),
u"Binding on property '" + propertyName + u"' of unknown type");
return;
}
const auto addObjectBinding = [&](const QString &value) {
if (qIsReferenceTypeList(property)) {
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
Q_ASSERT(unprocessedListProperty == property || unprocessedListBindings.empty());
unprocessedListBindings.append(value);
unprocessedListProperty = property;
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
} else {
QmltcCodeGenerator::generate_assignToProperty(&current.endInit.body, type, property,
value, accessor.name, true);
}
};
// special case of implicit or explicit component:
if (qsizetype index = m_visitor->qmlComponentIndex(object); index >= 0) {
const QString objectName = newSymbol(u"sc"_s);
const qsizetype creationIndex = m_visitor->creationIndex(object);
QStringList *block = (creationIndex == -1) ? &current.endInit.body : &current.init.body;
*block << u"{"_s;
*block << QStringLiteral("auto thisContext = QQmlData::get(%1)->outerContext;")
.arg(qobjectParent);
*block << QStringLiteral("auto %1 = QQmlObjectCreator::createComponent(engine, "
"%2, %3, %4, thisContext);")
.arg(objectName, generate_callCompilationUnit(m_urlMethodName),
QString::number(index), qobjectParent);
*block << QStringLiteral("thisContext->installContext(QQmlData::get(%1), "
"QQmlContextData::OrdinaryObject);")
.arg(objectName);
// objects wrapped in implicit components do not have visible ids,
// however, explicit components can have an id and that one is going
// to be visible in the common document context
if (creationIndex != -1) {
// explicit component
Q_ASSERT(object->isComposite());
Q_ASSERT(object->baseType()->internalName() == u"QQmlComponent"_s);
if (int id = m_visitor->runtimeId(object); id >= 0) {
qmllint: Fix attached property re-use detection Move the detection into the QtQuick lint plugin. It's mostly meant for QQC, so let's auto-enable it for attached types derived from QQuickAttachedPropertyPropagator. To this end, two new categories are introduced: The Quick lint plugin gets its own attached-property-reuse category which is synonymous to the default category of the same name. Furthermore, we add a controls-attached-property-reuse category for only checking controls. That one is implied by either of the others. Finally, fix the id vs. scope resolution to actually do something. This way we can give appropriate hints when the outer type has an ID already. Pick-to: 6.5 Fixes: QTBUG-110834 Change-Id: Ib71a9e3bbc10bac77f36db6cc441af88df20fd33 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-02-03 13:58:26 +00:00
QString idString = m_visitor->addressableScopes().id(object, object);
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
if (idString.isEmpty())
idString = u"<unknown>"_s;
QmltcCodeGenerator::generate_setIdValue(block, u"thisContext"_s, id, objectName,
idString);
}
const QString creationIndexStr = QString::number(creationIndex);
*block << QStringLiteral("creator->set(%1, %2);").arg(creationIndexStr, objectName);
Q_ASSERT(block == &current.init.body);
current.endInit.body << QStringLiteral("auto %1 = creator->get<%2>(%3);")
.arg(objectName, u"QQmlComponent"_s, creationIndexStr);
}
addObjectBinding(objectName);
*block << u"}"_s;
return;
}
const QString objectName = newSymbol(u"o"_s);
current.init.body << u"auto %1 = new %2(creator, engine, %3);"_s.arg(
objectName, object->internalName(), qobjectParent);
current.init.body << u"creator->set(%1, %2);"_s.arg(
QString::number(m_visitor->creationIndex(object)), objectName);
// refetch the same object during endInit to set the bindings
current.endInit.body << u"auto %1 = creator->get<%2>(%3);"_s.arg(
objectName, object->internalName(), QString::number(m_visitor->creationIndex(object)));
addObjectBinding(objectName);
}
/*!
* \internal
* Helper method used to keep compileBindingByType() readable.
*/
void QmltcCompiler::compileValueSourceOrInterceptorBinding(QmltcType &current,
const QQmlJSMetaPropertyBinding &binding,
const QQmlJSScope::ConstPtr &type,
const BindingAccessorData &accessor)
{
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
Q_ASSERT(binding.bindingType() == QQmlSA::BindingType::ValueSource
|| binding.bindingType() == QQmlSA::BindingType::Interceptor);
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
const QString &propertyName = binding.propertyName();
const QQmlJSMetaProperty property = type->property(propertyName);
QQmlJSScope::ConstPtr propertyType = property.type();
// NB: object is compiled with compileType(), here just need to use it
QSharedPointer<const QQmlJSScope> object;
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
if (binding.bindingType() == QQmlSA::BindingType::Interceptor)
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
object = binding.interceptorType();
else
object = binding.valueSourceType();
// Note: despite a binding being set for `accessor`, we use "this" as a
// parent of a created object. Both attached and grouped properties are
// parented by "this", so lifetime-wise we should be fine
const QString qobjectParent = u"this"_s;
if (!propertyType) {
recordError(binding.sourceLocation(),
u"Binding on property '" + propertyName + u"' of unknown type");
return;
}
auto &objectName = m_uniques[UniqueStringId(current, propertyName)].onAssignmentObjectName;
if (objectName.isEmpty()) {
objectName = u"onAssign_" + propertyName;
current.init.body << u"auto %1 = new %2(creator, engine, %3);"_s.arg(
objectName, object->internalName(), qobjectParent);
current.init.body << u"creator->set(%1, %2);"_s.arg(
QString::number(m_visitor->creationIndex(object)), objectName);
current.endInit.body << u"auto %1 = creator->get<%2>(%3);"_s.arg(
objectName, object->internalName(),
QString::number(m_visitor->creationIndex(object)));
}
// NB: we expect one "on" assignment per property, so creating
// QQmlProperty each time should be fine (unlike QQmlListReference)
current.endInit.body << u"{"_s;
current.endInit.body << u"QQmlProperty qmlprop(%1, %2);"_s.arg(
accessor.name, QQmlJSUtils::toLiteral(propertyName));
current.endInit.body << u"QT_PREPEND_NAMESPACE(QQmlCppOnAssignmentHelper)::set(%1, qmlprop);"_s
.arg(objectName);
current.endInit.body << u"}"_s;
}
/*!
* \internal
* Helper method used to keep compileBindingByType() readable.
*/
void QmltcCompiler::compileAttachedPropertyBinding(QmltcType &current,
const QQmlJSMetaPropertyBinding &binding,
const QQmlJSScope::ConstPtr &type,
const BindingAccessorData &accessor)
{
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
Q_ASSERT(binding.bindingType() == QQmlSA::BindingType::AttachedProperty);
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
const QString &propertyName = binding.propertyName();
const QQmlJSMetaProperty property = type->property(propertyName);
QQmlJSScope::ConstPtr propertyType = property.type();
Q_ASSERT(accessor.name == u"this"_s); // doesn't have to hold, in fact
QmlCompiler: Rename attachingType() to attachedType() That's what it actually is. It doesn't return the attacher but rather the attachment! Change-Id: I05e391d9d56ec0b8f56811eba491654dfa386bd9 Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2024-11-07 12:32:29 +00:00
const auto attachedType = binding.attachedType();
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
Q_ASSERT(attachedType);
const QString attachingTypeName = propertyName; // acts as an identifier
auto attachingType = m_typeResolver->typeForName(attachingTypeName);
QString attachedTypeName = attachedType->baseTypeName();
Q_ASSERT(!attachedTypeName.isEmpty());
auto &attachedMemberName =
m_uniques[UniqueStringId(current, propertyName)].attachedVariableName;
if (attachedMemberName.isEmpty()) {
qmltc: Fix usage of namespaced attached types We can't have a '.' in the variable name. Use '_' instead. In addition, disambiguate the names by always prepending a number to the part extracted from QML. This is safe because QML names can't start with numbers. Pick-to: 6.8 Fixes: QTBUG-130838 Change-Id: I1243070a3cb901bc4c2c108ecbec0c9cbbc57a55 Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2024-11-07 13:18:01 +00:00
attachedMemberName = uniqueVariableName(attachingTypeName);
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
// add attached type as a member variable to allow noop lookup
current.variables.emplaceBack(attachedTypeName + u" *", attachedMemberName, u"nullptr"_s);
if (propertyName == u"Component"_s) { // Component attached type is special
current.endInit.body << u"Q_ASSERT(qmlEngine(this));"_s;
current.endInit.body
<< u"// attached Component must be added to the object's QQmlData"_s;
current.endInit.body
<< u"Q_ASSERT(!QQmlEnginePrivate::get(qmlEngine(this))->activeObjectCreator);"_s;
}
// Note: getting attached property is fairly expensive
const QString getAttachedPropertyLine = u"qobject_cast<" + attachedTypeName
+ u" *>(qmlAttachedPropertiesObject<" + attachingType->internalName()
+ u">(this, /* create = */ true))";
current.endInit.body << attachedMemberName + u" = " + getAttachedPropertyLine + u";";
if (propertyName == u"Component"_s) {
// call completed/destruction signals appropriately
current.handleOnCompleted.body << u"Q_EMIT " + attachedMemberName + u"->completed();";
if (!current.dtor) {
current.dtor = QmltcDtor{};
current.dtor->name = u"~" + current.cppType;
}
current.dtor->body << u"Q_EMIT " + attachedMemberName + u"->destruction();";
}
}
auto subbindings = attachedType->ownPropertyBindingsInQmlIROrder();
// compile bindings of the attached property
partitionBindings(subbindings.begin(), subbindings.end());
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
compileBinding(current, subbindings.begin(), subbindings.end(), attachedType,
{ type, attachedMemberName, propertyName, false });
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
}
/*!
* \internal
* Helper method used to keep compileBindingByType() readable.
*/
void QmltcCompiler::compileGroupPropertyBinding(QmltcType &current,
const QQmlJSMetaPropertyBinding &binding,
const QQmlJSScope::ConstPtr &type,
const BindingAccessorData &accessor)
{
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
Q_ASSERT(binding.bindingType() == QQmlSA::BindingType::GroupProperty);
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
const QString &propertyName = binding.propertyName();
const QQmlJSMetaProperty property = type->property(propertyName);
QQmlJSScope::ConstPtr propertyType = property.type();
Q_ASSERT(accessor.name == u"this"_s); // doesn't have to hold, in fact
if (property.read().isEmpty()) {
recordError(binding.sourceLocation(),
u"READ function of group property '" + propertyName + u"' is unknown");
return;
}
auto groupType = binding.groupType();
Q_ASSERT(groupType);
const bool isValueType = propertyType->accessSemantics() == QQmlJSScope::AccessSemantics::Value;
if (!isValueType
&& propertyType->accessSemantics() != QQmlJSScope::AccessSemantics::Reference) {
recordError(binding.sourceLocation(),
u"Group property '" + propertyName + u"' has unsupported access semantics");
return;
}
auto subbindings = groupType->ownPropertyBindingsInQmlIROrder();
auto firstScript = partitionBindings(subbindings.begin(), subbindings.end());
// if we have no non-script bindings, we have no bindings that affect
// the value type group, so no reason to generate the wrapping code
const bool generateValueTypeCode = isValueType && (subbindings.begin() != firstScript);
QString groupAccessor = QmltcCodeGenerator::wrap_privateClass(accessor.name, property) + u"->"
+ property.read() + u"()";
// NB: used when isValueType == true
const QString groupPropertyVarName = accessor.name + u"_group_" + propertyName;
// value types are special
if (generateValueTypeCode) {
if (property.write().isEmpty()) { // just reject this
recordError(binding.sourceLocation(),
u"Group property '" + propertyName + u"' is a value type without a setter");
return;
}
current.endInit.body << u"auto " + groupPropertyVarName + u" = " + groupAccessor + u";";
// addressof operator is to make the binding logic work, which
// expects that `accessor.name` is a pointer type
groupAccessor = QmltcCodeGenerator::wrap_addressof(groupPropertyVarName);
}
// compile bindings of the grouped property
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
const auto compile = [&](const auto &bStart, const auto &bEnd) {
compileBinding(current, bStart, bEnd, groupType,
{ type, groupAccessor, propertyName, isValueType });
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
};
auto it = subbindings.begin();
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
Q_ASSERT(std::all_of(it, firstScript, [](const auto &x) {
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
return x.bindingType() != QQmlSA::BindingType::Script;
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
}));
compile(it, firstScript);
it = firstScript;
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
// NB: script bindings are special on group properties. if our group is
// a value type, the binding would be installed on the *object* that
// holds the value type and not on the value type itself. this may cause
// subtle side issues (esp. when script binding is actually a simple
// enum value assignment - which is not recognized specially):
//
// auto valueTypeGroupProperty = getCopy();
// installBinding(valueTypeGroupProperty, "subproperty1"); // changes subproperty1 value
// setCopy(valueTypeGroupProperty); // oops, subproperty1 value changed to old again
if (generateValueTypeCode) { // write the value type back
current.endInit.body << QmltcCodeGenerator::wrap_privateClass(accessor.name, property)
+ u"->" + property.write() + u"(" + groupPropertyVarName + u");";
}
// once the value is written back, process the script bindings
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
Q_ASSERT(std::all_of(it, subbindings.end(), [](const auto &x) {
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
return x.bindingType() == QQmlSA::BindingType::Script;
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
}));
compile(it, subbindings.end());
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
}
/*!
* \internal
* Helper method used to keep compileBindingByType() readable.
*/
void QmltcCompiler::compileTranslationBinding(QmltcType &current,
const QQmlJSMetaPropertyBinding &binding,
const QQmlJSScope::ConstPtr &type,
const BindingAccessorData &accessor)
{
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
Q_ASSERT(binding.bindingType() == QQmlSA::BindingType::Translation
|| binding.bindingType() == QQmlSA::BindingType::TranslationById);
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
const QString &propertyName = binding.propertyName();
auto [property, absoluteIndex] = getMetaPropertyIndex(type, propertyName);
if (absoluteIndex < 0) {
recordError(binding.sourceLocation(),
u"Binding on unknown property '" + propertyName + u"'");
return;
}
QString bindingTarget = accessor.name;
int valueTypeIndex = -1;
if (accessor.isValueType) {
Q_ASSERT(accessor.scope != type);
bindingTarget = u"this"_s; // TODO: not necessarily "this"?
auto [groupProperty, groupPropertyIndex] =
getMetaPropertyIndex(accessor.scope, accessor.propertyName);
if (groupPropertyIndex < 0) {
recordError(binding.sourceLocation(),
u"Binding on group property '" + accessor.propertyName
+ u"' of unknown type");
return;
}
valueTypeIndex = absoluteIndex;
absoluteIndex = groupPropertyIndex; // e.g. index of accessor.name
}
QmltcCodeGenerator::TranslationBindingInfo info;
info.unitVarName = generate_callCompilationUnit(m_urlMethodName);
info.scope = u"this"_s;
info.target = u"this"_s;
info.propertyIndex = absoluteIndex;
info.property = property;
info.data = binding.translationDataValue(m_url);
info.valueTypeIndex = valueTypeIndex;
info.line = binding.sourceLocation().startLine;
info.column = binding.sourceLocation().startColumn;
QmltcCodeGenerator::generate_createTranslationBindingOnProperty(&current.endInit.body, info);
}
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
void QmltcCompiler::processLastListBindings(QmltcType &current, const QQmlJSScope::ConstPtr &type,
const BindingAccessorData &accessor)
{
if (unprocessedListBindings.empty())
return;
QmltcCodeGenerator::generate_assignToListProperty(
&current.endInit.body, type, unprocessedListProperty, unprocessedListBindings,
accessor.name,
m_uniques[UniqueStringId(current, unprocessedListProperty.propertyName())]
.qmlListVariableName);
unprocessedListBindings.clear();
}
void QmltcCompiler::compileBinding(QmltcType &current,
QList<QQmlJSMetaPropertyBinding>::iterator bindingStart,
QList<QQmlJSMetaPropertyBinding>::iterator bindingEnd,
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
const QQmlJSScope::ConstPtr &type,
const BindingAccessorData &accessor)
{
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
for (auto it = bindingStart; it != bindingEnd; it++) {
const QQmlJSMetaPropertyBinding &binding = *it;
const QString &propertyName = binding.propertyName();
Q_ASSERT(!propertyName.isEmpty());
// Note: unlike QQmlObjectCreator, we don't have to do a complicated
// deferral logic for bindings: if a binding is deferred, it is not compiled
// (potentially, with all the bindings inside of it), period.
if (type->isNameDeferred(propertyName)) {
const auto location = binding.sourceLocation();
// make sure group property is not generalized by checking if type really has a property
// called propertyName. If not, it is probably an id.
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
if (binding.bindingType() == QQmlSA::BindingType::GroupProperty
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
&& type->hasProperty(propertyName)) {
qCWarning(lcQmltcCompiler)
<< QStringLiteral("Binding at line %1 column %2 is not deferred as it is a "
"binding on a group property.")
.arg(QString::number(location.startLine),
QString::number(location.startColumn));
// we do not support PropertyChanges and other types with similar
// behavior yet, so this binding is compiled
} else {
qCDebug(lcQmltcCompiler)
<< QStringLiteral(
"Binding at line %1 column %2 is deferred and thus not compiled")
.arg(QString::number(location.startLine),
QString::number(location.startColumn));
continue;
}
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
}
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
const QQmlJSMetaProperty metaProperty = type->property(propertyName);
const QQmlJSScope::ConstPtr propertyType = metaProperty.type();
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
if (!(qIsReferenceTypeList(metaProperty) && unprocessedListProperty == metaProperty)) {
processLastListBindings(current, type, accessor);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
}
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
compileBindingByType(current, binding, type, accessor);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
}
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
qmltc: append to lists in one go Instead of calling the methods to get the elements-to-be-appended and the append-calls alternatively, put first all the elements-to-be-appended on the stack before appending them all one after the other. Instead of compiling list bindings right away into an append call, collect all consecutive elements of a same list before printing all append calls. This requires knowing when all bindings are processed (else the last listbinding are collected but never compiled), such that this changes QmltcCompiler::compileBinding to accept lists of bindings instead of single bindings. Added private fields to QmltcCompiler to save the property of the current list and the list bindings collected so far. Fixes: QTBUG-106783 Change-Id: I75f71e828875e3d95540e6f33574bee7fa8bccbf Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-09-20 13:11:54 +00:00
processLastListBindings(current, type, accessor);
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
}
void QmltcCompiler::compileBindingByType(QmltcType &current,
const QQmlJSMetaPropertyBinding &binding,
const QQmlJSScope::ConstPtr &type,
const BindingAccessorData &accessor)
{
const QString &propertyName = binding.propertyName();
const QQmlJSMetaProperty metaProperty = type->property(propertyName);
const QQmlJSScope::ConstPtr propertyType = metaProperty.type();
const auto assignToProperty = [&](const QQmlJSMetaProperty &p, const QString &value,
bool constructFromQObject = false) {
QmltcCodeGenerator::generate_assignToProperty(&current.endInit.body, type, p, value,
accessor.name, constructFromQObject);
};
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
switch (binding.bindingType()) {
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::BoolLiteral: {
Refactor QQmlJSMetaPropertyBinding - Store the "binding content", i.e. the literal, object, interceptor or value source in a std::variant. This saves space compared to the previous approach (where we had individual fields), and also helps with type-safety. We also get rid of m_bindingType, which can now be obtained via BindingType(m_bindingContent.index()), as long as we keep the types in the variant in the correct order. - Remove a few methods that were not used anywhere. Those can be brought back once we actually need them. - Removed the setLiteral method in lieu of type-safe setX methods where X is one of the literal types. QQmlJSImportVisitor has been refactored to make use of this, and its parseLiteralBinding method has been changed into a parseLiteralOrScriptBinding method. This simplifies the control flow, and ensures that we always add the parsed binding. - Literals no longer store the literal type (as in, the actual QQmlJSScope pointer) themselves. Instead, literalType takes a pointer to a QQmlJSTypeResolver, and we use that one to resolve the type on demand. Change-Id: I0612d49f2f46fec0fa90f0f5047d8c9f831214ef Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-02-24 10:58:38 +00:00
const bool value = binding.boolValue();
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
assignToProperty(metaProperty, value ? u"true"_s : u"false"_s);
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
break;
}
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::NumberLiteral: {
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
assignToProperty(metaProperty, QString::number(binding.numberValue()));
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
break;
}
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::StringLiteral: {
qmltc: do not use the implicit QUrl constructor in generated code Instead, call the QUrl constructor explicitly when constructing url's from stringliterals. Add a test to show that binding string (not literal strings) to Url already uses the explicit QUrl constructor. Fixes: QTBUG-113875 Change-Id: I838437d9d45d57f416d78e71d718725975bee264 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2023-06-07 14:46:01 +00:00
QString value = QQmlJSUtils::toLiteral(binding.stringValue());
if (auto type = metaProperty.type()) {
if (type->internalName() == u"QUrl"_s) {
qmltc: remove useless std::move detected by code checker CodeChecker is unhappy about it and the value gets copied instead of moved. Report-hash:225e9bdd84a57c887f5b18b9d25d625d Amends 0978bb32a94473d74fa62ef96781278bcad863e7. Change-Id: I8d107c9c55b6b99eee5c515873f99673c3d9ee64 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-06-12 06:28:11 +00:00
value = u"QUrl(%1)"_s.arg(value);
qmltc: do not use the implicit QUrl constructor in generated code Instead, call the QUrl constructor explicitly when constructing url's from stringliterals. Add a test to show that binding string (not literal strings) to Url already uses the explicit QUrl constructor. Fixes: QTBUG-113875 Change-Id: I838437d9d45d57f416d78e71d718725975bee264 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2023-06-07 14:46:01 +00:00
}
}
assignToProperty(metaProperty, value);
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
break;
}
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::RegExpLiteral: {
Support RegExpLiteral bindings in qmltc Task-number: QTBUG-91956 Pick-to: 6.4 Change-Id: I02f8c6d1f0d6e4411985ffe3f22fb3c51fb36db6 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-26 14:29:02 +00:00
const QString value =
u"QRegularExpression(%1)"_s.arg(QQmlJSUtils::toLiteral(binding.regExpValue()));
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
assignToProperty(metaProperty, value);
Support RegExpLiteral bindings in qmltc Task-number: QTBUG-91956 Pick-to: 6.4 Change-Id: I02f8c6d1f0d6e4411985ffe3f22fb3c51fb36db6 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-26 14:29:02 +00:00
break;
}
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::Null: {
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
// poor check: null bindings are only supported for var and objects
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
Q_ASSERT(propertyType->isSameType(m_typeResolver->varType())
|| propertyType->accessSemantics() == QQmlJSScope::AccessSemantics::Reference);
if (propertyType->accessSemantics() == QQmlJSScope::AccessSemantics::Reference)
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
assignToProperty(metaProperty, u"nullptr"_s);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
else
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
assignToProperty(metaProperty, u"QVariant::fromValue(nullptr)"_s);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
break;
}
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::Script: {
qmltc: Fix usage of namespaced attached types We can't have a '.' in the variable name. Use '_' instead. In addition, disambiguate the names by always prepending a number to the part extracted from QML. This is safe because QML names can't start with numbers. Pick-to: 6.8 Fixes: QTBUG-130838 Change-Id: I1243070a3cb901bc4c2c108ecbec0c9cbbc57a55 Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2024-11-07 13:18:01 +00:00
QString bindingSymbolName
= uniqueVariableName(type->internalName() + u'_' + propertyName + u"_binding");
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
compileScriptBinding(current, binding, bindingSymbolName, type, propertyName, propertyType,
accessor);
break;
}
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::Object: {
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
compileObjectBinding(current, binding, type, accessor);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
break;
}
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::Interceptor:
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
Q_FALLTHROUGH();
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::ValueSource: {
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
compileValueSourceOrInterceptorBinding(current, binding, type, accessor);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
break;
}
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::AttachedProperty: {
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
compileAttachedPropertyBinding(current, binding, type, accessor);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
break;
}
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::GroupProperty: {
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
compileGroupPropertyBinding(current, binding, type, accessor);
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
break;
}
qmltc: translation binding support Implement and test support for translation bindings in qmltc: * qsTr() * QT_TR_NOOP() * qsTrId() * QT_TRID_NOOP() Not compiled by qmltc, but instead interpreted as script bindings: * combinations like qsTr(qsTr()) * qsTranslate() (as in qmlsc) * QT_TRANSLATE_NOOP() (as in qmlsc) Add the *.qm files directly to the resources as qt_add_translations() is not available from qtdeclarative (the cmake function lives in qttools that depends on qtdeclarative). Fixes: QTBUG-104637 Task-Id: QTBUG-105346 Change-Id: Ia9433c2bcef01f3486358d963059d9779c67708c Reviewed-by: Sami Shalayel <sami.shalayel@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-02 14:20:07 +00:00
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::TranslationById:
case QQmlSA::BindingType::Translation: {
qmltc: refactor compileBinding to be less unwieldy QmltcCompiler::compileBinding was getting big and unwieldy as it was compiling any kind of binding in a big switch-statement all by itself. Move the binding specific logic into separate helper methods and add a method that calls the right helper method depending on the binding type. This change prepares the code for QTBUG-106783. Task-number: QTBUG-106783 Change-Id: I900e182a82ae780186ad79a5cb5db31bd0548e33 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-09-20 09:30:58 +00:00
compileTranslationBinding(current, binding, type, accessor);
qmltc: translation binding support Implement and test support for translation bindings in qmltc: * qsTr() * QT_TR_NOOP() * qsTrId() * QT_TRID_NOOP() Not compiled by qmltc, but instead interpreted as script bindings: * combinations like qsTr(qsTr()) * qsTranslate() (as in qmlsc) * QT_TRANSLATE_NOOP() (as in qmlsc) Add the *.qm files directly to the resources as qt_add_translations() is not available from qtdeclarative (the cmake function lives in qttools that depends on qtdeclarative). Fixes: QTBUG-104637 Task-Id: QTBUG-105346 Change-Id: Ia9433c2bcef01f3486358d963059d9779c67708c Reviewed-by: Sami Shalayel <sami.shalayel@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-08-02 14:20:07 +00:00
break;
}
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
case QQmlSA::BindingType::Invalid: {
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
recordError(binding.sourceLocation(), u"This binding is invalid"_s);
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
break;
}
default: {
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
recordError(binding.sourceLocation(), u"Binding is not supported"_s);
qmltc: Support literal bindings Ignore type conversions for now. Expect C++ to handle them magically for us. The simple binding type dependent conversions that are performed already should suffice Task-number: QTBUG-84368 Change-Id: I62bd36ccf6c60fd62c2a50b6e011c637c5bcfbce Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-11-15 16:10:31 +00:00
break;
}
}
}
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
// returns compiled script binding for "property changed" handler in a form of object type
static QmltcType compileScriptBindingPropertyChangeHandler(const QQmlJSMetaPropertyBinding &binding,
const QQmlJSScope::ConstPtr &objectType,
const QString &urlMethodName,
const QString &functorCppType,
const QString &objectCppType)
{
QmltcType bindingFunctor {};
bindingFunctor.cppType = functorCppType;
bindingFunctor.ignoreInit = true;
// default member variable and ctor:
const QString pointerToObject = objectCppType + u" *";
bindingFunctor.variables.emplaceBack(
QmltcVariable { pointerToObject, u"m_self"_s, u"nullptr"_s });
bindingFunctor.baselineCtor.name = functorCppType;
bindingFunctor.baselineCtor.parameterList.emplaceBack(
QmltcVariable { pointerToObject, u"self"_s, QString() });
bindingFunctor.baselineCtor.initializerList.emplaceBack(u"m_self(self)"_s);
// call operator:
QmltcMethod callOperator {};
callOperator.returnType = u"void"_s;
callOperator.name = u"operator()"_s;
callOperator.modifiers << u"const"_s;
QmltcCodeGenerator::generate_callExecuteRuntimeFunction(
&callOperator.body, urlMethodName + u"()",
objectType->ownRuntimeFunctionIndex(binding.scriptIndex()), u"m_self"_s, u"void"_s, {});
bindingFunctor.functions.emplaceBack(std::move(callOperator));
return bindingFunctor;
}
// finds property for given scope and returns it together with the absolute
// property index in the property array of the corresponding QMetaObject
static std::pair<QQmlJSMetaProperty, int> getMetaPropertyIndex(const QQmlJSScope::ConstPtr &scope,
const QString &propertyName)
{
auto owner = QQmlJSScope::ownerOfProperty(scope, propertyName).scope;
Q_ASSERT(owner);
qmltc: Use QMetaObject hierarchy as reference for meta index calculation qmltc needs to compute a QMetaProperty index ahead of time when creating property bindings. This procedure has to acknowledge that extensions exist Change-Id: I7bf6b6c558ce78e0fec5ee880bc4d39a79fe5640 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-01 12:06:35 +00:00
const QQmlJSMetaProperty p = owner->ownProperty(propertyName);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
if (!p.isValid())
return { p, -1 };
int index = p.index();
if (index < 0) // this property doesn't have index - comes from QML
return { p, -1 };
qmltc: Use QMetaObject hierarchy as reference for meta index calculation qmltc needs to compute a QMetaProperty index ahead of time when creating property bindings. This procedure has to acknowledge that extensions exist Change-Id: I7bf6b6c558ce78e0fec5ee880bc4d39a79fe5640 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-01 12:06:35 +00:00
const auto increment = [&](const QQmlJSScope::ConstPtr &type, QQmlJSScope::ExtensionKind m) {
// owner of property is not included in the offset calculation (relative
// index is already added as p.index())
if (type->isSameType(owner))
return;
QML: Allow JavaScript extension types This is what we routinely do in the builtins. In particular: - Add the jsroot metatypes to qmltyperegistrar so that it can validate the JavaScript types - Add a special class info "ExtensionIsJavaScript" - Pass this through metatypes and qmltyperegistrar. - Treat it like an extension type in QQmlJSScope but give it its own name. - Ignore it in qmltc. We cannot express JavaScript extensions in C++. Now qmltyperegistrar has to deal with name conflicts between JavaScript and C++ types. It does so by always preferring the C++ type if available. The new class info is private and we don't want to surprisingly inject JavaScript types into people's QML modules. For our own types we shall make sure to avoid name conflicts. There is one prominent name conflict, 'Qt', which we really want to be resolved towards the C++ side. Change-Id: Iac224f4b0df2d6398fba0124f0b52d8ddfccace1 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Semih Yavuz <semih.yavuz@qt.io>
2023-11-09 14:58:38 +00:00
// extension namespace and JavaScript properties are ignored
if (m == QQmlJSScope::ExtensionNamespace || m == QQmlJSScope::ExtensionJavaScript)
qmltc: Use QMetaObject hierarchy as reference for meta index calculation qmltc needs to compute a QMetaProperty index ahead of time when creating property bindings. This procedure has to acknowledge that extensions exist Change-Id: I7bf6b6c558ce78e0fec5ee880bc4d39a79fe5640 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-01 12:06:35 +00:00
return;
QML: Allow JavaScript extension types This is what we routinely do in the builtins. In particular: - Add the jsroot metatypes to qmltyperegistrar so that it can validate the JavaScript types - Add a special class info "ExtensionIsJavaScript" - Pass this through metatypes and qmltyperegistrar. - Treat it like an extension type in QQmlJSScope but give it its own name. - Ignore it in qmltc. We cannot express JavaScript extensions in C++. Now qmltyperegistrar has to deal with name conflicts between JavaScript and C++ types. It does so by always preferring the C++ type if available. The new class info is private and we don't want to surprisingly inject JavaScript types into people's QML modules. For our own types we shall make sure to avoid name conflicts. There is one prominent name conflict, 'Qt', which we really want to be resolved towards the C++ side. Change-Id: Iac224f4b0df2d6398fba0124f0b52d8ddfccace1 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Semih Yavuz <semih.yavuz@qt.io>
2023-11-09 14:58:38 +00:00
qmltc: Use QMetaObject hierarchy as reference for meta index calculation qmltc needs to compute a QMetaProperty index ahead of time when creating property bindings. This procedure has to acknowledge that extensions exist Change-Id: I7bf6b6c558ce78e0fec5ee880bc4d39a79fe5640 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-01 12:06:35 +00:00
index += int(type->ownProperties().size());
};
QQmlJSUtils::traverseFollowingMetaObjectHierarchy(scope, owner, increment);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
return { p, index };
}
void QmltcCompiler::compileScriptBinding(QmltcType &current,
const QQmlJSMetaPropertyBinding &binding,
const QString &bindingSymbolName,
const QQmlJSScope::ConstPtr &objectType,
const QString &propertyName,
const QQmlJSScope::ConstPtr &propertyType,
const QmltcCompiler::BindingAccessorData &accessor)
{
const auto compileScriptSignal = [&](const QString &name) {
QString This_signal = u"this"_s;
QString This_slot = u"this"_s;
QString objectClassName_signal = objectType->internalName();
QString objectClassName_slot = objectType->internalName();
// TODO: ugly crutch to make stuff work
if (accessor.name != u"this"_s) { // e.g. if attached property
This_signal = accessor.name;
This_slot = u"this"_s; // still
objectClassName_signal = objectType->baseTypeName();
objectClassName_slot = current.cppType; // real base class where slot would go
}
Q_ASSERT(!objectClassName_signal.isEmpty());
Q_ASSERT(!objectClassName_slot.isEmpty());
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
const auto signalMethods = objectType->methods(name, QQmlJSMetaMethodType::Signal);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
Q_ASSERT(!signalMethods.isEmpty()); // an error somewhere else
QQmlJSMetaMethod signal = signalMethods.at(0);
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
Q_ASSERT(signal.methodType() == QQmlJSMetaMethodType::Signal);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
const QString signalName = signal.methodName();
const QString slotName = newSymbol(signalName + u"_slot");
QmlCompiler: Assume missing return types to be "void" qmltyperegistrar leaves out "void" return types when generating methods and signals. Add those back when reading the files so that we don't have to special-case "void" in the compilers. Also, explicitly set the return type of QML signals to "void", for the same reason. Change-Id: I94cd9d005c458fe37160eccf5c14f02c53fc300a Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2024-06-18 14:17:16 +00:00
const QString signalReturnType = signal.returnType()->augmentedInternalName();
QQmlJSMetaParameter: Encapsulate parameter information Previously, there were four lists that contained each one entry for each parameter. There was one list responsible for the names, types, type names and const-qualifiers but this was quite bothersome to use (e.g. they not always had the same length). This commit introduces QQmlJSMetaParameter to encapsulate all the information required when manipulating parameters. This reduce the 4 lists to one, making parameters easier to handle and QQmlJSMetaMethod easier to read. This is a purely refactoring change, no new functionality was added. Task-number: QTBUG-107625 Change-Id: Ia41b823c9e6294ee26e828071b802cac6b4058ce Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-11-10 10:38:51 +00:00
const QList<QmltcVariable> slotParameters =
compileMethodParameters(signal.parameters(), /* allow unnamed = */ true);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
// SignalHander specific:
QmltcMethod slotMethod {};
slotMethod.returnType = signalReturnType;
slotMethod.name = slotName;
slotMethod.parameterList = slotParameters;
QmltcCodeGenerator::generate_callExecuteRuntimeFunction(
&slotMethod.body, m_urlMethodName + u"()",
objectType->ownRuntimeFunctionIndex(binding.scriptIndex()),
u"this"_s, // Note: because script bindings always use current QML object scope
signalReturnType, slotParameters);
QQmlSA: Create an abstraction layer for static analysis This patch adds abstractions for QML Elements, Bindings, Methods and Properties. This abstraction layer avoids exposing internal details and should be more suited for static analysis tasks. It is now possible to write qmllint plugins without including private headers. As a drive-by, change tst_qmllint:verifyJsRoot to open files in text mode instead of binary. This fixes an issue where line endings cause issues on Windows. Fixes: QTBUG-102276 Change-Id: I6b6e53f1e0078734a18f3aa51807fbe875b375f0 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-05-05 07:30:27 +00:00
slotMethod.type = QQmlJSMetaMethodType::Slot;
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
current.functions << std::move(slotMethod);
qmltc: fix handlers for c++-signals Allow qmltc to generate handlers for c++-defined signals with const parameters by changing the safeguard to avoid type mismatch between slots and signals. First, remove the qOverload in the generated QObject::connect call to be able the connect slots and signals with different types (namely, pass by const references and pass by value should be interchangeable but is not allowed by qOverload). Second, save in QQmlJSMetaParameter when types are passed by pointer. Like this, qqmljsimportvisitor can check if a value type is indeed passed by value or const reference in a C++ signal. The same for reference types that need to be passed by (const and non-const) pointer. Print a message when an type is passed by argument in an incompatible way instead of letting qmltc generate uncompilable code, which makes the compiler print out cryptical messages. Third, add a qqmlcpptypehelpers template that decides if value types should be passed by value or reference, by letting the c++ compiler check if sizeof(T) > 3*sizeof(void*). Fixes: QTBUG-107625 Fixes: QTBUG-107622 Change-Id: I1a00532df591d10f74c1fd00dff5b7fccf40cb22 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-10-12 13:56:00 +00:00
current.setComplexBindings.body << u"QObject::connect(" + This_signal + u", " + u"&"
+ objectClassName_signal + u"::" + signalName + u", " + This_slot + u", &"
+ objectClassName_slot + u"::" + slotName + u");";
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
};
switch (binding.scriptKind()) {
QQmlSA::ScriptBindingKind: Turn into scoped enumeration and remove the Script_ prefix from its entries. This is more aligned with Qt's namings conventions. Pick-to: 6.6 Change-Id: Ie97c2ce204b5532ab6bd6b136145f2a537175fbb Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Semih Yavuz <semih.yavuz@qt.io> Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2023-08-30 08:35:00 +00:00
case QQmlSA::ScriptBindingKind::PropertyBinding: {
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
if (!propertyType) {
recordError(binding.sourceLocation(),
u"Binding on property '" + propertyName + u"' of unknown type");
return;
}
auto [property, absoluteIndex] = getMetaPropertyIndex(objectType, propertyName);
if (absoluteIndex < 0) {
recordError(binding.sourceLocation(),
u"Binding on unknown property '" + propertyName + u"'");
return;
}
QString bindingTarget = accessor.name;
int valueTypeIndex = -1;
if (accessor.isValueType) {
Q_ASSERT(accessor.scope != objectType);
bindingTarget = u"this"_s; // TODO: not necessarily "this"?
auto [groupProperty, groupPropertyIndex] =
getMetaPropertyIndex(accessor.scope, accessor.propertyName);
if (groupPropertyIndex < 0) {
recordError(binding.sourceLocation(),
u"Binding on group property '" + accessor.propertyName
+ u"' of unknown type");
return;
}
valueTypeIndex = absoluteIndex;
absoluteIndex = groupPropertyIndex; // e.g. index of accessor.name
}
QmltcCodeGenerator::generate_createBindingOnProperty(
Separate script bindings from others in generated qmltc code Align script binding creation to QQmlObjectCreator model: simple bindings (e.g. literal, object, etc.) are created instantly when encountered; complex bindings (e.g. script, translation?) are posponed until QQmlObjectCreator::finalize() (in reality it is a bit more complicated). Make qmltc follow this logic by creating script bindings in a separate object creation step Additionally, this should theoretically improve performance of the object creation process as script bindings (that have interdependencies) would now re-trigger less as they are all centrally created at once (after simple bindings are already done). Note, however, that the specific order of binding creation between children may vary in comparison to QQmlObjectCreator Task-number: QTBUG-91956 Task-number: QTBUG-96269 Pick-to: 6.4 Change-Id: I25067adf7b16d0f1852a5108a0b6d6597ac28a53 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-27 15:03:44 +00:00
&current.setComplexBindings.body, generate_callCompilationUnit(m_urlMethodName),
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
u"this"_s, // NB: always using enclosing object as a scope for the binding
static_cast<qsizetype>(objectType->ownRuntimeFunctionIndex(binding.scriptIndex())),
bindingTarget, // binding target
qmltc: Use QMetaObject hierarchy as reference for meta index calculation qmltc needs to compute a QMetaProperty index ahead of time when creating property bindings. This procedure has to acknowledge that extensions exist Change-Id: I7bf6b6c558ce78e0fec5ee880bc4d39a79fe5640 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-07-01 12:06:35 +00:00
// value types are special and are bound through valueTypeIndex
accessor.isValueType ? QQmlJSScope::ConstPtr() : objectType, absoluteIndex,
property, valueTypeIndex, accessor.name);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
break;
}
QQmlSA::ScriptBindingKind: Turn into scoped enumeration and remove the Script_ prefix from its entries. This is more aligned with Qt's namings conventions. Pick-to: 6.6 Change-Id: Ie97c2ce204b5532ab6bd6b136145f2a537175fbb Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Semih Yavuz <semih.yavuz@qt.io> Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2023-08-30 08:35:00 +00:00
case QQmlSA::ScriptBindingKind::SignalHandler: {
Replace signal name manipulations with QQmlSignalNames Remove custom implementations found in qqmljs* and use the static helper methods from qqmlsignalnames_p.h instead. This sometimes requires to move some code around to avoid bugs with property that do not have letters in their name. Add a warning in the JS implementation of the SignalSpy.qml that the used heuristic might fail on certain signal names. Add tests in in tst_qqmllanguage to see if the property change handlers work correctly for weird names. Change-Id: I4dc73c34df7f77f529511fa04ab5fcc5385b59fc Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-08-10 07:45:37 +00:00
const auto name = QQmlSignalNames::handlerNameToSignalName(propertyName);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
Q_ASSERT(name.has_value());
compileScriptSignal(*name);
break;
}
QQmlSA::ScriptBindingKind: Turn into scoped enumeration and remove the Script_ prefix from its entries. This is more aligned with Qt's namings conventions. Pick-to: 6.6 Change-Id: Ie97c2ce204b5532ab6bd6b136145f2a537175fbb Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Semih Yavuz <semih.yavuz@qt.io> Reviewed-by: Olivier De Cannière <olivier.decanniere@qt.io>
2023-08-30 08:35:00 +00:00
case QQmlSA ::ScriptBindingKind::ChangeHandler: {
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
const QString objectClassName = objectType->internalName();
const QString bindingFunctorName = newSymbol(bindingSymbolName + u"Functor");
Replace signal name manipulations with QQmlSignalNames Remove custom implementations found in qqmljs* and use the static helper methods from qqmlsignalnames_p.h instead. This sometimes requires to move some code around to avoid bugs with property that do not have letters in their name. Add a warning in the JS implementation of the SignalSpy.qml that the used heuristic might fail on certain signal names. Add tests in in tst_qqmllanguage to see if the property change handlers work correctly for weird names. Change-Id: I4dc73c34df7f77f529511fa04ab5fcc5385b59fc Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-08-10 07:45:37 +00:00
const auto signalName = QQmlSignalNames::handlerNameToSignalName(propertyName);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
Q_ASSERT(signalName.has_value()); // an error somewhere else
Replace signal name manipulations with QQmlSignalNames Remove custom implementations found in qqmljs* and use the static helper methods from qqmlsignalnames_p.h instead. This sometimes requires to move some code around to avoid bugs with property that do not have letters in their name. Add a warning in the JS implementation of the SignalSpy.qml that the used heuristic might fail on certain signal names. Add tests in in tst_qqmllanguage to see if the property change handlers work correctly for weird names. Change-Id: I4dc73c34df7f77f529511fa04ab5fcc5385b59fc Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-08-10 07:45:37 +00:00
const auto actualProperty =
QQmlJSUtils::propertyFromChangedHandler(objectType, propertyName);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
Q_ASSERT(actualProperty.has_value()); // an error somewhere else
const auto actualPropertyType = actualProperty->type();
if (!actualPropertyType) {
recordError(binding.sourceLocation(),
u"Binding on property '" + actualProperty->propertyName()
+ u"' of unknown type");
return;
}
// due to historical reasons (QQmlObjectCreator), prefer NOTIFY over
// BINDABLE when both are available. thus, test for notify first
const QString notifyString = actualProperty->notify();
if (!notifyString.isEmpty()) {
compileScriptSignal(notifyString);
break;
}
const QString bindableString = actualProperty->bindable();
QString typeOfQmlBinding =
u"std::unique_ptr<QPropertyChangeHandler<" + bindingFunctorName + u">>";
current.children << compileScriptBindingPropertyChangeHandler(
binding, objectType, m_urlMethodName, bindingFunctorName, objectClassName);
qmltc: Wrap raw string literal in QStringLiteral This fixes build failures with QT_NO_CAST_FROM_ASCII. Pick-to: 6.8 Task-number: QTBUG-130081 Change-Id: I0c46005b9eda58cf6ab44ea4dd95043b8851af51 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2024-10-16 08:38:30 +00:00
current.setComplexBindings.body << u"if (!%1.contains(QStringLiteral(\"%2\")))"_s.arg(
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
current.propertyInitializer.initializedCache.name, propertyName);
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
// TODO: this could be dropped if QQmlEngine::setContextForObject() is
// done before currently generated C++ object is constructed
qmltc: Allow setting initial values when creating a compiled type `qmltc`-generated types currently do not allow setting any initial values for the property of a component during creation. For example, some component `Foo` with a property `bar`, will have no way to set `bar` to a specific value from the C++ side of the code before an instance of `Foo` is obtained by the user. This lack of control prohibits the user from interacting with certain processes that are part of the component creation. For example, if a component provides am `onCompleted` binding that depends on some of the values of its properties, the user is inhibited from varying the per-instance values that `onCompleted` depends on, as the user would be able to vary those values only after the component is created and the `onCompleted` signal is emitted. This differs, from example, from the `QQmlComponent` interface, where the user is able to provide some initialization values as part of the creation of an instance of the component. To allow the user to have more control in the initialization of the instance of a component, before it is fully created, `qmltc` generated code now allows the user to provide an initialization callback that is processed as part of the creation cycle of an instance of the component. The callback provides the user with a generated proxy object, `PropertyInitializer`, that only knows how to set the writable, non-private properties of the component. The generated code for the public constructor of a `qmltc`-generated type was modified to provide an optional `initializer` parameter that stores the callback. The private `QML_init` method that `qmltc` generates for each type, that performs the required setup to create an instance of a component, was modified to allow for the same optional parameter, which is passed on by the public constructor. The body of `QML_init` was modified to call the new parameter, after having performed the general set-up for the created instance but before the instance is completed and before setting up "complex bindings" such as an `onPropertyChanged` handler. The callback is called with an instance of the generated proxy object that is built on-site. The proxy-object keeps track of the properties that were actually initialized by the callback. This information is now passed down to `QML_setComplexBindings`, which avoids setting up any unnecessary bindings for the properties that were initialized. A representation for the proxy object was added to the internal IR that is used by `qmltc` when generating code. The representation for a compiled C++ type was modified to store an instance of the proxy object. The newly stored instance is now populated as part of the general compilation of a type, by the `compilePropertyInitializer` free-function in "qmltccompiler.cpp". The component responsible for the final code-generation, `QmltcCodeWriter`, was modified to be able to generate code for the new proxy object representation. The documentation for `QmltcCodeGenerator::generate_initCode`, which sets up the body for `QML_init`, was updated to reflect the new body. A pre-existing issue in the documentation of the method, which failed to enumerate all generated steps for the body, was fixed as part of the change. The preamble that `qmltc` generates for all generated header files was modified to include "QtCore/qxpfunction.h", to have access to `qxp::function_ref`, which is used to store the new callback parameter. A pre-existing snapshot test had its snapshot file, "src/qml/doc/snippets/qmltc/special/HelloWorld.qml.cpp", updated to reflect the changes to the generated code. A new basic, non-exhaustive test case was added to the available corpus of `qmltc` tests to test the basic workflow of providing an initialization callback. The documentation for `qmltc` was modified to mention the new parameter. Task-number: QTBUG-120700 Change-Id: I246c1c3634982580d66b31fd891382559a9cc3ae Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-03-11 15:33:35 +00:00
current.setComplexBindings.body << u" "_s + bindingSymbolName + u".reset(new QPropertyChangeHandler<"
qmltc: Move from QmlIR::Binding to QQmlJSMetaPropertyBinding This symbolizes the last piece of QmlIR dependency that qmltc has. We do still have some implicit dependencies on QmlIR, though, but that should go way once the remaining prototype code's logic is migrated to QmltcVisitor, QQmlJSScope and friends. This, however, is not attempted here as the patch itself is rather large In the process of switching to QQmlJSMetaPropertyBinding, observe and fix issues in QmltcVisitor and surroundings Pick-to: 6.4 Change-Id: I752b68a7f57baf354de16dc0bb466a3f693a4e49 Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2022-05-12 12:39:38 +00:00
+ bindingFunctorName + u">("
+ QmltcCodeGenerator::wrap_privateClass(accessor.name, *actualProperty)
+ u"->" + bindableString + u"().onValueChanged(" + bindingFunctorName + u"("
+ accessor.name + u"))));";
current.variables.emplaceBack(
QmltcVariable { typeOfQmlBinding, bindingSymbolName, QString() });
break;
}
default:
recordError(binding.sourceLocation(), u"Invalid script binding found"_s);
break;
}
}
Long live (dummy-for-now) qmltc! This is a stub commit that introduces qmltc as a binary We don't even attempt to generate any code here yet Task-number: QTBUG-84368 Change-Id: I98da17d839970a2561f501f3b9d6b1e1310e0e01 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-16 07:35:33 +00:00
QT_END_NAMESPACE