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

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>
This commit is contained in:
Ulf Hermann 2025-08-25 11:00:35 +02:00
parent d8d55cd69a
commit e69a4b17cd
16 changed files with 78 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/qmlcompiler/qqmljscodegenerator.cpp
View File

@ -118,8 +118,8 @@ QString QQmlJSCodeGenerator::metaType(const QQmlJSScope::ConstPtr &type)
return compositeMetaType(name);
}
if (type->isListProperty() && type->valueType()->isComposite()) {
const QString name = m_typeResolver->nameForType(type->valueType());
if (type->isListProperty() && type->elementType()->isComposite()) {
const QString name = m_typeResolver->nameForType(type->elementType());
Q_ASSERT(!name.isEmpty()); // There can't be a list with anonymous composite value type
return compositeListMetaType(name);
}
@ -854,7 +854,7 @@ void QQmlJSCodeGenerator::generate_LoadElement(int base)
}
// Since we can do .at() below, we know that we can natively store the element type.
QQmlJSRegisterContent elementType = m_typeResolver->valueType(baseType);
QQmlJSRegisterContent elementType = m_typeResolver->elementType(baseType);
elementType = m_pool->storedIn(
elementType, m_typeResolver->storedType(elementType.containedType()));
@ -891,8 +891,8 @@ void QQmlJSCodeGenerator::generate_StoreElement(int base, int index)
const QString baseName = registerVariable(base);
const QString indexName = registerVariable(index);
const auto valueType = m_typeResolver->valueType(baseType);
const auto elementType = m_typeResolver->genericType(valueType.containedType());
const auto elementType = m_typeResolver->genericType(
m_typeResolver->elementType(baseType).containedType());
addInclude(u"QtQml/qjslist.h"_s);
if (!m_typeResolver->isNativeArrayIndex(indexType))
@ -1133,13 +1133,13 @@ void QQmlJSCodeGenerator::generateVariantEqualityComparison(
void QQmlJSCodeGenerator::generateArrayInitializer(int argc, int argv)
{
const QQmlJSScope::ConstPtr stored = m_state.accumulatorOut().storedType();
const QQmlJSScope::ConstPtr value = stored->valueType();
Q_ASSERT(value);
const QQmlJSScope::ConstPtr element = stored->elementType();
Q_ASSERT(element);
QStringList initializer;
for (int i = 0; i < argc; ++i) {
initializer += convertStored(
registerType(argv + i).storedType(), value,
registerType(argv + i).storedType(), element,
consumedRegisterVariable(argv + i));
}
@ -1399,7 +1399,7 @@ bool QQmlJSCodeGenerator::isRegisterAffectedBySideEffects(int registerIndex)
case QQmlJSRegisterContent::Operation:
case QQmlJSRegisterContent::Literal: {
// Stack-created lists of primitives and pointers can't be affected by side effects
const QQmlJSScope::ConstPtr elementContained = contained->valueType();
const QQmlJSScope::ConstPtr elementContained = contained->elementType();
return !elementContained->isReferenceType()
&& !m_typeResolver->isPrimitive(elementContained);
}
@ -2227,7 +2227,7 @@ bool QQmlJSCodeGenerator::inlineConsoleMethod(const QString &name, int argc, int
bool QQmlJSCodeGenerator::inlineArrayMethod(const QString &name, int base, int argc, int argv)
{
const auto intType = m_typeResolver->int32Type();
const auto valueType = registerType(base).storedType()->valueType();
const auto elementType = registerType(base).storedType()->elementType();
const auto boolType = m_typeResolver->boolType();
const auto stringType = m_typeResolver->stringType();
const auto baseType = registerType(base);
@ -2240,7 +2240,7 @@ bool QQmlJSCodeGenerator::inlineArrayMethod(const QString &name, int base, int a
if (name == u"includes" && argc > 0 && argc < 3) {
QString call = qjsListMethod
+ convertStored(registerType(argv).storedType(), valueType,
+ convertStored(registerType(argv).storedType(), elementType,
consumedRegisterVariable(argv));
if (argc == 2) {
call += u", " + convertStored(registerType(argv + 1).storedType(), intType,
@ -2288,7 +2288,7 @@ bool QQmlJSCodeGenerator::inlineArrayMethod(const QString &name, int base, int a
if ((name == u"indexOf" || name == u"lastIndexOf") && argc > 0 && argc < 3) {
QString call = qjsListMethod
+ convertStored(registerType(argv).storedType(), valueType,
+ convertStored(registerType(argv).storedType(), elementType,
consumedRegisterVariable(argv));
if (argc == 2) {
call += u", " + convertStored(registerType(argv + 1).storedType(), intType,
@ -4312,7 +4312,7 @@ QString QQmlJSCodeGenerator::convertStored(
if (from->isListProperty()
&& to->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence
&& to->valueType()->isReferenceType()
&& to->elementType()->isReferenceType()
&& !to->isListProperty()) {
return variable + u".toList<"_s + to->internalName() + u">()"_s;
}

7
src/qmlcompiler/qqmljsoptimizations.cpp
View File

@ -352,15 +352,16 @@ void QQmlJSOptimizations::adjustTypes()
// Now we don't adjust the type we store, but rather the type we expect to read. We
// can do this because we've tracked the read type when we defined the array in
// QQmlJSTypePropagator.
if (QQmlJSScope::ConstPtr valueType = it->trackedTypes[0].containedType()->valueType()) {
if (const QQmlJSScope::ConstPtr elementType
= it->trackedTypes[0].containedType()->elementType()) {
const QQmlJSRegisterContent content = annotation.readRegisters.begin().value().content;
const QQmlJSScope::ConstPtr contained = content.containedType();
// If it's the 1-arg Array ctor, and the argument is a number, that's special.
if (mode != ObjectOrArrayDefinition::ArrayConstruct1ArgId
|| contained != m_typeResolver->realType()) {
if (!m_typeResolver->adjustTrackedType(content, valueType))
addError(adjustErrorMessage(content, valueType));
if (!m_typeResolver->adjustTrackedType(content, elementType))
addError(adjustErrorMessage(content, elementType));
}
}

12
src/qmlcompiler/qqmljsscope.cpp
View File

@ -472,8 +472,8 @@ QTypeRevision QQmlJSScope::resolveType(
if (!self->m_attachedType && !self->m_attachedTypeName.isEmpty())
self->m_attachedType = findType(self->m_attachedTypeName, context, usedTypes).scope;
if (!self->m_valueType && !self->m_valueTypeName.isEmpty())
self->m_valueType = findType(self->m_valueTypeName, context, usedTypes).scope;
if (!self->m_elementType && !self->m_elementTypeName.isEmpty())
self->m_elementType = findType(self->m_elementTypeName, context, usedTypes).scope;
if (!self->m_extensionType) {
if (self->m_extensionTypeName.isEmpty()) {
@ -693,12 +693,12 @@ void QQmlJSScope::resolveList(const QQmlJSScope::Ptr &self, const QQmlJSScope::C
Q_ASSERT(!arrayType.isNull());
QQmlJSScope::Ptr listType = QQmlJSScope::create();
listType->setAccessSemantics(AccessSemantics::Sequence);
listType->setValueTypeName(self->internalName());
listType->setElementTypeName(self->internalName());
if (self->isComposite()) {
// There is no internalName for this thing. Just set the value type right away
listType->setInternalName(u"QQmlListProperty<>"_s);
listType->m_valueType = QQmlJSScope::ConstPtr(self);
listType->m_elementType = QQmlJSScope::ConstPtr(self);
} else if (self->isReferenceType()) {
listType->setInternalName(u"QQmlListProperty<%2>"_s.arg(self->internalName()));
// Do not set a filePath on the list type, so that we have to generalize it
@ -717,7 +717,7 @@ void QQmlJSScope::resolveList(const QQmlJSScope::Ptr &self, const QQmlJSScope::C
arrayType);
QQmlJSScope::resolveTypes(listType, contextualTypes);
Q_ASSERT(listType->valueType() == self);
Q_ASSERT(listType->elementType() == self);
self->m_listType = listType;
}
@ -1252,7 +1252,7 @@ bool QQmlJSScope::canAssign(const QQmlJSScope::ConstPtr &derived) const
if (internalName() == u"QVariant"_s || internalName() == u"QJSValue"_s)
return true;
return isListProperty() && valueType()->canAssign(derived);
return isListProperty() && elementType()->canAssign(derived);
}
/*!

12
src/qmlcompiler/qqmljsscope_p.h
View File

@ -320,9 +320,9 @@ public:
};
AnnotatedScope extensionType() const;
QString valueTypeName() const { return m_valueTypeName; }
void setValueTypeName(const QString &name) { m_valueTypeName = name; }
QQmlJSScope::ConstPtr valueType() const { return m_valueType; }
QString elementTypeName() const { return m_elementTypeName; }
void setElementTypeName(const QString &name) { m_elementTypeName = name; }
QQmlJSScope::ConstPtr elementType() const { return m_elementType; }
QQmlJSScope::ConstPtr listType() const { return m_listType; }
QQmlJSScope::Ptr listType() { return m_listType; }
@ -534,11 +534,11 @@ private:
QQmlJSScope::WeakConstPtr m_attachedType;
/*! \internal
* The Value type name.
* The type name of the list element in case this is a sequence type.
* This is an internal name, from a c++ type or a synthetic jsrootgen.
*/
QString m_valueTypeName;
QQmlJSScope::WeakConstPtr m_valueType;
QString m_elementTypeName;
QQmlJSScope::WeakConstPtr m_elementType;
QQmlJSScope::Ptr m_listType;
/*!

2
src/qmlcompiler/qqmljstypedescriptionreader.cpp
View File

@ -213,7 +213,7 @@ void QQmlJSTypeDescriptionReader::readComponent(UiObjectDefinition *ast)
} else if (name == QLatin1String("attachedType")) {
scope->setOwnAttachedTypeName(readStringBinding(script));
} else if (name == QLatin1String("valueType")) {
scope->setValueTypeName(readStringBinding(script));
scope->setElementTypeName(readStringBinding(script));
} else if (name == QLatin1String("isSingleton")) {
scope->setIsSingleton(readBoolBinding(script));
} else if (name == QLatin1String("isCreatable")) {

32
src/qmlcompiler/qqmljstypepropagator.cpp
View File

@ -795,7 +795,7 @@ void QQmlJSTypePropagator::generate_LoadElement(int base)
setAccumulator(m_pool->createProperty(
property, QQmlJSRegisterContent::InvalidLookupIndex,
QQmlJSRegisterContent::InvalidLookupIndex, QQmlJSRegisterContent::ListValue,
m_typeResolver->convert(m_typeResolver->valueType(baseRegister), jsValue)));
m_typeResolver->convert(m_typeResolver->elementType(baseRegister), jsValue)));
};
if (baseRegister.isList()) {
@ -824,7 +824,7 @@ void QQmlJSTypePropagator::generate_LoadElement(int base)
// We can end up with undefined.
setAccumulator(m_typeResolver->merge(
m_typeResolver->valueType(baseRegister),
m_typeResolver->elementType(baseRegister),
m_typeResolver->literalType(m_typeResolver->voidType())));
}
@ -855,7 +855,7 @@ void QQmlJSTypePropagator::generate_StoreElement(int base, int index)
addReadRegister(index, m_typeResolver->realType());
addReadRegister(base, m_typeResolver->arrayPrototype());
addReadAccumulator(m_typeResolver->valueType(baseRegister));
addReadAccumulator(m_typeResolver->elementType(baseRegister));
// If we're writing a QQmlListProperty backed by a container somewhere else,
// that has side effects.
@ -1891,7 +1891,7 @@ bool QQmlJSTypePropagator::propagateArrayMethod(
const auto intType = m_typeResolver->int32Type();
const auto stringType = m_typeResolver->stringType();
const auto baseContained = baseType.containedType();
const auto valueContained = baseContained->valueType();
const auto elementContained = baseContained->elementType();
const auto setReturnType = [&](const QQmlJSScope::ConstPtr type) {
QQmlJSMetaMethod method;
@ -1915,7 +1915,7 @@ bool QQmlJSTypePropagator::propagateArrayMethod(
}
if (name == u"fill" && argc > 0 && argc < 4) {
if (!canConvertFromTo(m_state.registers[argv].content, valueContained))
if (!canConvertFromTo(m_state.registers[argv].content, elementContained))
return false;
for (int i = 1; i < argc; ++i) {
@ -1923,7 +1923,7 @@ bool QQmlJSTypePropagator::propagateArrayMethod(
return false;
}
addReadRegister(argv, valueContained);
addReadRegister(argv, elementContained);
for (int i = 1; i < argc; ++i)
addReadRegister(argv + i, intType);
@ -1934,7 +1934,7 @@ bool QQmlJSTypePropagator::propagateArrayMethod(
}
if (name == u"includes" && argc > 0 && argc < 3) {
if (!canConvertFromTo(m_state.registers[argv].content, valueContained))
if (!canConvertFromTo(m_state.registers[argv].content, elementContained))
return false;
if (argc == 2) {
@ -1943,7 +1943,7 @@ bool QQmlJSTypePropagator::propagateArrayMethod(
addReadRegister(argv + 1, intType);
}
addReadRegister(argv, valueContained);
addReadRegister(argv, elementContained);
setReturnType(m_typeResolver->boolType());
return true;
}
@ -1961,18 +1961,18 @@ bool QQmlJSTypePropagator::propagateArrayMethod(
if ((name == u"pop" || name == u"shift") && argc == 0) {
m_state.setHasExternalSideEffects();
setReturnType(valueContained);
setReturnType(elementContained);
return true;
}
if (name == u"push" || name == u"unshift") {
for (int i = 0; i < argc; ++i) {
if (!canConvertFromTo(m_state.registers[argv + i].content, valueContained))
if (!canConvertFromTo(m_state.registers[argv + i].content, elementContained))
return false;
}
for (int i = 0; i < argc; ++i)
addReadRegister(argv + i, valueContained);
addReadRegister(argv + i, elementContained);
m_state.setHasExternalSideEffects();
setReturnType(m_typeResolver->int32Type());
@ -2007,7 +2007,7 @@ bool QQmlJSTypePropagator::propagateArrayMethod(
}
for (int i = 2; i < argc; ++i) {
if (!canConvertFromTo(m_state.registers[argv + i].content, valueContained))
if (!canConvertFromTo(m_state.registers[argv + i].content, elementContained))
return false;
}
@ -2015,7 +2015,7 @@ bool QQmlJSTypePropagator::propagateArrayMethod(
addReadRegister(argv + i, intType);
for (int i = 2; i < argc; ++i)
addReadRegister(argv + i, valueContained);
addReadRegister(argv + i, elementContained);
m_state.setHasExternalSideEffects();
setReturnType(baseContained);
@ -2023,7 +2023,7 @@ bool QQmlJSTypePropagator::propagateArrayMethod(
}
if ((name == u"indexOf" || name == u"lastIndexOf") && argc > 0 && argc < 3) {
if (!canConvertFromTo(m_state.registers[argv].content, valueContained))
if (!canConvertFromTo(m_state.registers[argv].content, elementContained))
return false;
if (argc == 2) {
@ -2032,7 +2032,7 @@ bool QQmlJSTypePropagator::propagateArrayMethod(
addReadRegister(argv + 1, intType);
}
addReadRegister(argv, valueContained);
addReadRegister(argv, elementContained);
setReturnType(m_typeResolver->int32Type());
return true;
}
@ -2374,7 +2374,7 @@ void QQmlJSTypePropagator::generate_IteratorNext(int value, int offset)
const QQmlJSRegisterContent iteratorType = m_state.accumulatorIn();
addReadAccumulator();
setRegister(value, m_typeResolver->merge(
m_typeResolver->valueType(iteratorType),
m_typeResolver->elementType(iteratorType),
m_typeResolver->literalType(m_typeResolver->voidType())));
saveRegisterStateForJump(offset);
m_state.setHasInternalSideEffects();

23
src/qmlcompiler/qqmljstyperesolver.cpp
View File

@ -136,7 +136,7 @@ QQmlJSTypeResolver::QQmlJSTypeResolver(QQmlJSImporter *importer)
m_listPropertyType = m_qObjectType->listType();
Q_ASSERT(m_listPropertyType->internalName() == u"QQmlListProperty<QObject>"_s);
Q_ASSERT(m_listPropertyType->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence);
Q_ASSERT(m_listPropertyType->valueTypeName() == u"QObject"_s);
Q_ASSERT(m_listPropertyType->elementTypeName() == u"QObject"_s);
assertExtension(m_listPropertyType, "Array"_L1);
QQmlJSScope::Ptr emptyType = QQmlJSScope::create();
@ -788,8 +788,8 @@ bool QQmlJSTypeResolver::canHold(
if (container == m_qObjectListType || container == m_listPropertyType) {
if (contained->accessSemantics() != QQmlJSScope::AccessSemantics::Sequence)
return false;
if (QQmlJSScope::ConstPtr value = contained->valueType())
return value->isReferenceType();
if (QQmlJSScope::ConstPtr element = contained->elementType())
return element->isReferenceType();
return false;
}
@ -1520,18 +1520,19 @@ bool QQmlJSTypeResolver::canPrimitivelyConvertFromTo(
if (from->isListProperty()
&& to->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence
&& canConvertFromTo(from->valueType(), to->valueType())) {
&& canConvertFromTo(from->elementType(), to->elementType())) {
return true;
}
// it is possible to assing a singlar object to a list property if it could be stored in the list
if (to->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence
&& from->accessSemantics() == QQmlJSScope::AccessSemantics::Reference
&& from->inherits(to->valueType()))
&& from->accessSemantics() == QQmlJSScope::AccessSemantics::Reference
&& from->inherits(to->elementType())) {
return true;
}
if (to == m_stringType && from->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence)
return canConvertFromTo(from->valueType(), m_stringType);
return canConvertFromTo(from->elementType(), m_stringType);
return false;
}
@ -1740,19 +1741,19 @@ QQmlJSRegisterContent QQmlJSTypeResolver::memberType(
Q_UNREACHABLE_RETURN({});
}
QQmlJSRegisterContent QQmlJSTypeResolver::valueType(QQmlJSRegisterContent list) const
QQmlJSRegisterContent QQmlJSTypeResolver::elementType(QQmlJSRegisterContent list) const
{
QQmlJSScope::ConstPtr value;
auto valueType = [&](const QQmlJSScope::ConstPtr &scope) -> QQmlJSScope::ConstPtr {
if (scope->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence)
return scope->valueType();
return scope->elementType();
if (scope == m_forInIteratorPtr)
return m_sizeType;
if (scope == m_forOfIteratorPtr)
return list.scopeType()->valueType();
return list.scopeType()->elementType();
if (scope == m_jsValueType || scope == m_varType)
return m_jsValueType;
@ -1827,7 +1828,7 @@ QQmlJSRegisterContent QQmlJSTypeResolver::iteratorPointer(
{
const QQmlJSScope::ConstPtr value = (type == QQmlJS::AST::ForEachType::In)
? m_int32Type
: valueType(listType).containedType();
: elementType(listType).containedType();
QQmlJSScope::ConstPtr iteratorPointer = type == QQmlJS::AST::ForEachType::In
? m_forInIteratorPtr

2
src/qmlcompiler/qqmljstyperesolver_p.h
View File

@ -242,7 +242,7 @@ public:
QQmlJSRegisterContent type, const QString &name,
int lookupIndex = QQmlJSRegisterContent::InvalidLookupIndex) const;
QQmlJSRegisterContent valueType(QQmlJSRegisterContent list) const;
QQmlJSRegisterContent elementType(QQmlJSRegisterContent list) const;
QQmlJSRegisterContent returnType(
const QQmlJSMetaMethod &method, const QQmlJSScope::ConstPtr &returnType,

2
src/qmldom/qqmldomelements.cpp
View File

@ -1322,7 +1322,7 @@ bool QmltypesComponent::iterateDirectSubpaths(const DomItem &self, DirectVisitor
cont = cont && self.dvValueField(visitor, Fields::fileName, fileName()); // remove?
cont = cont && self.dvValueField(visitor, Fields::interfaceNames, m_interfaceNames);
cont = cont && self.dvValueField(visitor, Fields::hasCustomParser, m_hasCustomParser);
cont = cont && self.dvValueField(visitor, Fields::valueTypeName, m_valueTypeName);
cont = cont && self.dvValueField(visitor, Fields::elementTypeName, m_elementTypeName);
cont = cont && self.dvValueField(visitor, Fields::extensionTypeName, m_extensionTypeName);
cont = cont && self.dvValueField(visitor, Fields::accessSemantics, int(m_accessSemantics));
return cont;

6
src/qmldom/qqmldomelements_p.h
View File

@ -1120,8 +1120,8 @@ public:
const QStringList &interfaceNames() const & { return m_interfaceNames; }
QString extensionTypeName() const { return m_extensionTypeName; }
void setExtensionTypeName(const QString &name) { m_extensionTypeName = name; }
QString valueTypeName() const { return m_valueTypeName; }
void setValueTypeName(const QString &name) { m_valueTypeName = name; }
QString elementTypeName() const { return m_elementTypeName; }
void setElementTypeName(const QString &name) { m_elementTypeName = name; }
bool hasCustomParser() const { return m_hasCustomParser; }
void setHasCustomParser(bool v) { m_hasCustomParser = v; }
bool extensionIsJavaScript() const { return m_extensionIsJavaScript; }
@ -1142,7 +1142,7 @@ private:
bool m_hasCustomParser = false;
bool m_extensionIsJavaScript = false;
bool m_extensionIsNamespace = false;
QString m_valueTypeName;
QString m_elementTypeName;
QString m_extensionTypeName;
QQmlJSScope::AccessSemantics m_accessSemantics = QQmlJSScope::AccessSemantics::None;
QQmlJSScope::ConstPtr m_semanticScope;

2
src/qmldom/qqmldompath_p.h
View File

@ -578,7 +578,7 @@ QMLDOM_FIELD(uris);
QMLDOM_FIELD(validExposedAt);
QMLDOM_FIELD(validItem);
QMLDOM_FIELD(value);
QMLDOM_FIELD(valueTypeName);
QMLDOM_FIELD(elementTypeName);
QMLDOM_FIELD(values);
QMLDOM_FIELD(version);
QMLDOM_FIELD(when);

2
src/qmldom/qqmldomtypesreader.cpp
View File

@ -176,7 +176,7 @@ void QmltypesReader::insertComponent(const QQmlJSScope::ConstPtr &jsScope,
comp.setIsCreatable(jsScope->isCreatable());
comp.setIsComposite(jsScope->isComposite());
comp.setHasCustomParser(jsScope->hasCustomParser());
comp.setValueTypeName(jsScope->valueTypeName());
comp.setElementTypeName(jsScope->elementTypeName());
comp.setAccessSemantics(jsScope->accessSemantics());
comp.setExtensionTypeName(jsScope->extensionTypeName());
comp.setExtensionIsJavaScript(jsScope->extensionIsJavaScript());

14
tools/qmltc/qmltccompiler.cpp
View File

@ -113,7 +113,7 @@ static void compileRequiredPropertiesBundle(
[](const QQmlJSMetaProperty &property) {
QString type = qIsReferenceTypeList(property)
? u"const QList<%1*>&"_s.arg(
property.type()->valueType()->internalName())
property.type()->elementType()->internalName())
: u"passByConstRefOrValue<%1>"_s.arg(
property.type()->augmentedInternalName());
return QmltcVariable{ type, property.propertyName() };
@ -569,7 +569,7 @@ void QmltcCompiler::compilePropertyInitializer(
if (qIsReferenceTypeList(property)) {
compiledSetter.parameterList.emplaceBack(
QQmlJSUtils::constRefify(
u"QList<%1*>"_s.arg(propertyType->valueType()->internalName())),
u"QList<%1*>"_s.arg(propertyType->elementType()->internalName())),
name + u"_", QString()
);
} else {
@ -756,7 +756,7 @@ void QmltcCompiler::compileMethod(QmltcType &current, const QQmlJSMetaMethod &m,
void QmltcCompiler::compileExtraListMethods(QmltcType &current, const QQmlJSMetaProperty &p)
{
QmltcPropertyData data(p);
const QString valueType = p.type()->valueType()->internalName() + u'*';
const QString elementType = p.type()->elementType()->internalName() + u'*';
const QString variableName = data.read + u"()"_s;
const QStringList ownershipWarning = {
u"\\note {This method does not change the ownership of its argument."_s,
@ -773,7 +773,7 @@ void QmltcCompiler::compileExtraListMethods(QmltcType &current, const QQmlJSMeta
append.comments << ownershipWarning;
append.returnType = u"void"_s;
append.name = u"%1Append"_s.arg(data.read);
append.parameterList.emplaceBack(valueType, u"toBeAppended"_s);
append.parameterList.emplaceBack(elementType, u"toBeAppended"_s);
append.body << u"auto q_qmltc_localList = %1;"_s.arg(variableName);
append.body
@ -802,7 +802,7 @@ void QmltcCompiler::compileExtraListMethods(QmltcType &current, const QQmlJSMeta
{
QmltcMethod at{};
at.comments.emplaceBack(u"\\brief Access an element in %1."_s.arg(data.read));
at.returnType = valueType;
at.returnType = elementType;
at.name = u"%1At"_s.arg(data.read);
at.parameterList.emplaceBack(u"qsizetype"_s, u"position"_s, QString());
@ -836,7 +836,7 @@ void QmltcCompiler::compileExtraListMethods(QmltcType &current, const QQmlJSMeta
replace.returnType = u"void"_s;
replace.name = u"%1Replace"_s.arg(data.read);
replace.parameterList.emplaceBack(u"qsizetype"_s, u"position"_s, QString());
replace.parameterList.emplaceBack(valueType, u"element"_s,
replace.parameterList.emplaceBack(elementType, u"element"_s,
QString());
replace.body << u"auto q_qmltc_localList = %1;"_s.arg(variableName);
@ -877,7 +877,7 @@ void QmltcCompiler::compileProperty(QmltcType &current, const QQmlJSMetaProperty
if (qIsReferenceTypeList(p)) {
const QString storageName = variableName + u"_storage";
current.variables.emplaceBack(
u"QList<" + p.type()->valueType()->internalName() + u"*>", storageName,
u"QList<" + p.type()->elementType()->internalName() + u"*>", storageName,
QString());
current.baselineCtor.initializerList.emplaceBack(variableName + u"(" + underlyingType
+ u"(this, std::addressof(" + storageName

4
tools/qmltc/qmltccompilerpieces.cpp
View File

@ -97,8 +97,8 @@ void QmltcCodeGenerator::generate_assignToListProperty(
type, p, QmltcCodeGenerator::wrap_privateClass(accessor, p));
qmlListVarName = u"listprop_%1"_s.arg(p.propertyName());
QQmlJSScope::ConstPtr valueType = p.type()->valueType();
*block << u"QQmlListProperty<%1> %2;"_s.arg(valueType->internalName(), qmlListVarName);
const QQmlJSScope::ConstPtr elementType = p.type()->elementType();
*block << u"QQmlListProperty<%1> %2;"_s.arg(elementType->internalName(), qmlListVarName);
*block << extensionPrologue;
*block << u"%1 = %2->%3();"_s.arg(qmlListVarName, extensionAccessor, p.read());
*block << extensionEpilogue;

6
tools/qmltc/qmltcpropertyutils.h
View File

@ -20,9 +20,9 @@ inline QString getUnderlyingType(const QQmlJSMetaProperty &p)
if (p.isList()) {
// We cannot just use p.type()->internalName() here because it may be
// a list property of something that only receives a C++ name from qmltc.
const QQmlJSScope::ConstPtr valueType = p.type()->valueType();
return (valueType->isReferenceType() ? u"QQmlListProperty<" : u"QList<")
+ valueType->internalName() + u'>';
const QQmlJSScope::ConstPtr elementType = p.type()->elementType();
return (elementType->isReferenceType() ? u"QQmlListProperty<" : u"QList<")
+ elementType->internalName() + u'>';
}
return p.type()->augmentedInternalName();

2
tools/qmltc/qmltcvisitor.cpp
View File

@ -103,7 +103,7 @@ void QmltcVisitor::findCppIncludes()
addCppInclude(type);
if (type->isListProperty())
addCppInclude(type->valueType());
addCppInclude(type->elementType());
// look in type's base type
auto base = type->baseType();