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>

src/qmlcompiler/qqmljscodegenerator.cpp

@@ -118,8 +118,8 @@ QString QQmlJSCodeGenerator::metaType(const QQmlJSScope::ConstPtr &type)
         return compositeMetaType(name);
     }
 
-    if (type->isListProperty() && type->valueType()->isComposite()) {
+    if (type->isListProperty() && type->elementType()->isComposite()) {
-        const QString name = m_typeResolver->nameForType(type->valueType());
+        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(
-    const auto elementType = m_typeResolver->genericType(valueType.containedType());
+            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();
+    const QQmlJSScope::ConstPtr element = stored->elementType();
-    Q_ASSERT(value);
+    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;
     }

src/qmlcompiler/qqmljsoptimizations.cpp

@@ -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))
+                if (!m_typeResolver->adjustTrackedType(content, elementType))
-                    addError(adjustErrorMessage(content, valueType));
+                    addError(adjustErrorMessage(content, elementType));
             }
         }
 

src/qmlcompiler/qqmljsscope.cpp

@@ -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())
+    if (!self->m_elementType && !self->m_elementTypeName.isEmpty())
-        self->m_valueType = findType(self->m_valueTypeName, context, usedTypes).scope;
+        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);
 }
 
 /*!

src/qmlcompiler/qqmljsscope_p.h

@@ -320,9 +320,9 @@ public:
     };
     AnnotatedScope extensionType() const;
 
-    QString valueTypeName() const { return m_valueTypeName; }
+    QString elementTypeName() const { return m_elementTypeName; }
-    void setValueTypeName(const QString &name) { m_valueTypeName = name; }
+    void setElementTypeName(const QString &name) { m_elementTypeName = name; }
-    QQmlJSScope::ConstPtr valueType() const { return m_valueType; }
+    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;
+    QString m_elementTypeName;
-    QQmlJSScope::WeakConstPtr m_valueType;
+    QQmlJSScope::WeakConstPtr m_elementType;
     QQmlJSScope::Ptr m_listType;
 
     /*!

src/qmlcompiler/qqmljstypedescriptionreader.cpp

@@ -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")) {

src/qmlcompiler/qqmljstypepropagator.cpp

@@ -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();

src/qmlcompiler/qqmljstyperesolver.cpp

@@ -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())
+        if (QQmlJSScope::ConstPtr element = contained->elementType())
-            return value->isReferenceType();
+            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->accessSemantics()  == QQmlJSScope::AccessSemantics::Reference
-        &&  from->inherits(to->valueType()))
+            && 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

src/qmlcompiler/qqmljstyperesolver_p.h

@@ -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,

src/qmldom/qqmldomelements.cpp

@@ -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;

src/qmldom/qqmldomelements_p.h

@@ -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; }
+    QString elementTypeName() const { return m_elementTypeName; }
-    void setValueTypeName(const QString &name) { m_valueTypeName = name; }
+    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;

src/qmldom/qqmldompath_p.h

@@ -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);

src/qmldom/qqmldomtypesreader.cpp

@@ -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());

tools/qmltc/qmltccompiler.cpp

@@ -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

tools/qmltc/qmltccompilerpieces.cpp

@@ -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();
+        const QQmlJSScope::ConstPtr elementType = p.type()->elementType();
-        *block << u"QQmlListProperty<%1> %2;"_s.arg(valueType->internalName(), qmlListVarName);
+        *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;

tools/qmltc/qmltcpropertyutils.h

@@ -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();
+        const QQmlJSScope::ConstPtr elementType = p.type()->elementType();
-        return (valueType->isReferenceType() ? u"QQmlListProperty<" : u"QList<")
+        return (elementType->isReferenceType() ? u"QQmlListProperty<" : u"QList<")
-                + valueType->internalName() + u'>';
+                + elementType->internalName() + u'>';
     }
 
     return p.type()->augmentedInternalName();

tools/qmltc/qmltcvisitor.cpp

@@ -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();