3#ifndef QQMLPROPERTYCACHECREATOR_P_H
4#define QQMLPROPERTYCACHECREATOR_P_H
17#include <private/qqmlvaluetype_p.h>
18#include <private/qqmlengine_p.h>
19#include <private/qqmlmetaobject_p.h>
20#include <private/qqmlpropertyresolver_p.h>
21#include <private/qqmltypedata_p.h>
22#include <private/inlinecomponentutils_p.h>
23#include <private/qqmlsourcecoordinate_p.h>
24#include <private/qqmlsignalnames_p.h>
26#include <QScopedValueRollback>
28#if QT_CONFIG(regularexpression)
29#include <QtCore/qregularexpression.h>
40 error.setLine(qmlConvertSourceCoordinate<quint32, int>(
location.line()));
41 error.setColumn(qmlConvertSourceCoordinate<quint32, int>(
location.column()));
42 error.setDescription(description);
88#if QT_CONFIG(regularexpression)
114#if QT_CONFIG(regularexpression)
142template <
typename ObjectContainer>
147 using InlineComponent =
typename std::remove_reference<decltype (*(std::declval<CompiledObject>().inlineComponentsBegin()))>
::type;
202template <
typename ObjectContainer>
206 const ObjectContainer *objectContainer,
const QQmlImports *imports,
208 : enginePrivate(enginePrivate)
209 , objectContainer(objectContainer)
211 , propertyCaches(propertyCaches)
212 , pendingGroupPropertyBindings(pendingGroupPropertyBindings)
213 , typeClassName(typeClassName)
224 for (
auto it =
obj->inlineComponentsBegin();
it !=
obj->inlineComponentsEnd(); ++
it) {
230 std::vector<icutils::Node> nodes;
231 nodes.resize(
allICs.size());
232 std::iota(nodes.begin(), nodes.end(), 0);
234 adjacencyList.resize(nodes.size());
241template <
typename ObjectContainer>
252template <
typename ObjectContainer>
260 if (nodeIt != nodesSorted.rend()) {
261 const auto &ic = allICs[nodeIt->index()];
264 Q_ASSERT(typeRef->typePropertyCache().isNull());
266 QByteArray icTypeName { objectContainer->stringAt(ic.nameIndex).toUtf8() };
267 QScopedValueRollback<QByteArray> nameChange {typeClassName, icTypeName};
268 QScopedValueRollback<unsigned int> rootChange {currentRoot, ic.objectIndex};
270 QQmlError diag = buildMetaObjectRecursively(ic.objectIndex, m_context, VMEMetaObjectIsRequired::Always);
271 if (diag.isValid()) {
272 return {diag,
false, 0};
274 typeRef->setTypePropertyCache(propertyCaches->
at(ic.objectIndex));
275 Q_ASSERT(!typeRef->typePropertyCache().isNull());
276 return {
QQmlError(),
true, int(ic.objectIndex) };
279 auto diag = buildMetaObjectRecursively(0, m_context, VMEMetaObjectIsRequired::Maybe);
280 return {diag,
false, 0};
283template <
typename ObjectContainer>
286 auto isAddressable = [](
const QUrl &
url) {
292 bool needVMEMetaObject = isVMERequired == VMEMetaObjectIsRequired::Always ||
obj->propertyCount() != 0 ||
obj->aliasCount() != 0
293 ||
obj->signalCount() != 0 ||
obj->functionCount() != 0 ||
obj->enumCount() != 0
295 || (objectIndex == 0 && isAddressable(objectContainer->url())))
296 && !objectContainer->resolvedType(
obj->inheritedTypeNameIndex)->isFullyDynamicType());
298 if (!needVMEMetaObject) {
299 auto binding =
obj->bindingsBegin();
300 auto end =
obj->bindingsEnd();
301 for ( ; binding !=
end; ++binding) {
311 auto *typeRef = objectContainer->resolvedType(
obj->inheritedTypeNameIndex);
315 ? createMetaObject(
context.referencingObjectIndex,
obj, baseTypeCache)
317 "Type cannot be used for 'on' assignment"));
323 needVMEMetaObject =
true;
339 if (needVMEMetaObject) {
344 propertyCaches->
set(objectIndex, baseTypeCache);
349 auto binding =
obj->bindingsBegin();
350 auto end =
obj->bindingsEnd();
351 for (; binding !=
end; ++binding) {
352 switch (binding->type()) {
364 objectIndex, &(*binding), stringAt(binding->propertyNameIndex), thisCache);
370 if (!thisCache || !
context.resolveInstantiatingProperty())
374 binding->value.objectIndex,
context, VMEMetaObjectIsRequired::Maybe);
383template <
typename ObjectContainer>
386 if (
context.instantiatingProperty) {
387 return context.instantiatingPropertyCache();
388 }
else if (
obj->inheritedTypeNameIndex != 0) {
389 auto *typeRef = objectContainer->resolvedType(
obj->inheritedTypeNameIndex);
392 if (typeRef->isFullyDynamicType()) {
393 if (
obj->propertyCount() > 0 ||
obj->aliasCount() > 0) {
394 *
error =
qQmlCompileError(
obj->location, QQmlPropertyCacheCreatorBase::tr(
"Fully dynamic types cannot declare new properties."));
397 if (
obj->signalCount() > 0) {
398 *
error =
qQmlCompileError(
obj->location, QQmlPropertyCacheCreatorBase::tr(
"Fully dynamic types cannot declare new signals."));
401 if (
obj->functionCount() > 0) {
402 *
error =
qQmlCompileError(
obj->location, QQmlPropertyCacheCreatorBase::tr(
"Fully Dynamic types cannot declare new functions."));
408 return propertyCache;
411 QQmlPropertyCacheCreatorBase::tr(
"Type '%1' cannot declare new members.")
412 .arg(stringAt(
obj->inheritedTypeNameIndex)));
415 if (binding->isAttachedProperty()) {
416 auto *typeRef = objectContainer->resolvedType(
417 binding->propertyNameIndex);
420 if (!qmltype.isValid()) {
423 &qmltype,
nullptr,
nullptr);
426 const QMetaObject *attachedMo = qmltype.attachedPropertiesType(enginePrivate);
428 *
error =
qQmlCompileError(binding->location, QQmlPropertyCacheCreatorBase::tr(
"Non-existent attached object"));
437template <
typename ObjectContainer>
443 obj->propertyCount() +
obj->aliasCount(),
444 obj->functionCount() +
obj->propertyCount() +
obj->aliasCount() +
obj->signalCount(),
445 obj->signalCount() +
obj->propertyCount() +
obj->aliasCount(),
453 if (objectIndex == 0 ||
int(currentRoot) == objectIndex) {
454 newClassName = typeClassName;
456 if (newClassName.isEmpty()) {
458 newClassName.append(
"_QML_");
462 cache->_dynamicClassName = newClassName;
464 using ListPropertyAssignBehavior =
typename ObjectContainer::ListPropertyAssignBehavior;
465 switch (objectContainer->listPropertyAssignBehavior()) {
466 case ListPropertyAssignBehavior::ReplaceIfNotDefault:
467 cache->_listPropertyAssignBehavior =
"ReplaceIfNotDefault";
469 case ListPropertyAssignBehavior::Replace:
470 cache->_listPropertyAssignBehavior =
"Replace";
472 case ListPropertyAssignBehavior::Append:
478 auto p =
obj->propertiesBegin();
479 auto pend =
obj->propertiesEnd();
480 for ( ;
p != pend; ++
p) {
481 bool notInRevision =
false;
483 if (
d &&
d->isFinal())
484 return qQmlCompileError(
p->location, QQmlPropertyCacheCreatorBase::tr(
"Cannot override FINAL property"));
487 auto a =
obj->aliasesBegin();
488 auto aend =
obj->aliasesEnd();
489 for ( ;
a != aend; ++
a) {
490 bool notInRevision =
false;
492 if (
d &&
d->isFinal())
493 return qQmlCompileError(
a->location, QQmlPropertyCacheCreatorBase::tr(
"Cannot override FINAL property"));
496 int effectivePropertyIndex =
cache->propertyIndexCacheStart;
497 int effectiveMethodIndex =
cache->methodIndexCacheStart;
503 enum class AllowOverride { No, Yes };
504 QHash<QString, AllowOverride> seenSignals {
510 while ((parentCache = parentCache->parent().data())) {
511 if (
int pSigCount = parentCache->signalCount()) {
512 int pSigOffset = parentCache->signalOffset();
513 for (
int i = pSigOffset;
i < pSigCount; ++
i) {
517 iter != parentCache->stringCache.end(); ++
iter) {
518 if (currPSig == (*iter).second) {
519 if (currPSig->isOverridableSignal()) {
520 const qsizetype oldSize = seenSignals.size();
521 AllowOverride &
entry = seenSignals[
iter.key()];
522 if (seenSignals.size() != oldSize)
523 entry = AllowOverride::Yes;
525 seenSignals[
iter.key()] = AllowOverride::No;
536 p =
obj->propertiesBegin();
537 pend =
obj->propertiesEnd();
538 for ( ;
p != pend; ++
p) {
543 seenSignals[changedSigName] = AllowOverride::No;
545 cache->appendSignal(changedSigName,
flags, effectiveMethodIndex++);
548 a =
obj->aliasesBegin();
549 aend =
obj->aliasesEnd();
550 for ( ;
a != aend; ++
a) {
555 seenSignals[changedSigName] = AllowOverride::No;
557 cache->appendSignal(changedSigName,
flags, effectiveMethodIndex++);
560 auto e =
obj->enumsBegin();
561 auto eend =
obj->enumsEnd();
562 for ( ; e != eend; ++e) {
563 const int enumValueCount = e->enumValueCount();
564 QVector<QQmlEnumValue>
values;
565 values.reserve(enumValueCount);
567 auto enumValue = e->enumValuesBegin();
568 auto end = e->enumValuesEnd();
569 for ( ; enumValue !=
end; ++enumValue)
576 auto s =
obj->signalsBegin();
577 auto send =
obj->signalsEnd();
578 for ( ;
s != send; ++
s) {
579 const int paramCount =
s->parameterCount();
581 QList<QByteArray>
names;
582 names.reserve(paramCount);
583 QVarLengthArray<QMetaType, 10> paramTypes(paramCount);
588 auto param =
s->parametersBegin();
589 auto end =
s->parametersEnd();
591 names.append(stringAt(
param->nameIndex).toUtf8());
596 return qQmlCompileError(
s->location, QQmlPropertyCacheCreatorBase::tr(
"Invalid signal parameter type: %1").arg(customTypeName));
598 paramTypes[
i] =
type;
604 flags.setHasArguments(
true);
606 QString signalName = stringAt(
s->nameIndex);
607 const auto it = seenSignals.
find(signalName);
608 if (
it == seenSignals.
end()) {
609 seenSignals[signalName] = AllowOverride::No;
614 QQmlPropertyCacheCreatorBase::tr(
615 "Duplicate signal name: "
616 "invalid override of property change signal or superclass signal"));
618 case AllowOverride::No:
620 case AllowOverride::Yes:
621 message.setUrl(objectContainer->url());
623 *
it = AllowOverride::No;
627 cache->appendSignal(signalName,
flags, effectiveMethodIndex++,
628 paramCount?paramTypes.constData():
nullptr,
names);
633 auto function = objectContainer->objectFunctionsBegin(
obj);
634 auto fend = objectContainer->objectFunctionsEnd(
obj);
635 for ( ; function != fend; ++
function) {
638 const QString slotName = stringAt(function->nameIndex);
644 QQmlPropertyCacheCreatorBase::tr(
645 "Duplicate method name: "
646 "invalid override of property change signal or superclass signal"));
648 case AllowOverride::No:
650 case AllowOverride::Yes:
651 message.setUrl(objectContainer->url());
659 QList<QByteArray> parameterNames;
660 QVector<QMetaType> parameterTypes;
661 auto formal = function->formalsBegin();
662 auto end = function->formalsEnd();
663 for ( ; formal !=
end; ++formal) {
664 flags.setHasArguments(
true);
665 parameterNames << stringAt(formal->nameIndex).toUtf8();
668 type = QMetaType::fromType<QVariant>();
669 parameterTypes <<
type;
672 QMetaType returnType = metaTypeForParameter(function->returnType);
674 returnType = QMetaType::fromType<QVariant>();
676 cache->appendMethod(slotName,
flags, effectiveMethodIndex++, returnType, parameterNames, parameterTypes);
681 int effectiveSignalIndex =
cache->signalHandlerIndexCacheStart;
683 p =
obj->propertiesBegin();
684 pend =
obj->propertiesEnd();
685 for ( ;
p != pend; ++
p, ++propertyIdx) {
693 propertyFlags.
setType(QQmlPropertyData::Flags::QListType);
695 propertyFlags.setType(QQmlPropertyData::Flags::VarPropertyType);
698 propertyType =
p->isList()
699 ? listTypeForPropertyType(
type)
700 : metaTypeForPropertyType(
type);
705 bool selfReference =
false;
708 stringAt(
p->commonTypeOrTypeNameIndex()), &qmltype,
nullptr,
nullptr,
710 return qQmlCompileError(
p->location, QQmlPropertyCacheCreatorBase::tr(
"Invalid property type"));
715 if (qmltype.isComposite() || qmltype.isInlineComponentType()) {
717 if (qmltype.isInlineComponentType()) {
718 compositeType = qmltype;
720 }
else if (selfReference) {
721 compositeType = objectContainer->qmlTypeForComponent();
726 QQmlRefPointer<QQmlTypeData> tdata
730 compositeType = tdata->compilationUnit()->qmlTypeForComponent();
734 propertyType = compositeType.qListTypeId();
736 propertyType = compositeType.typeId();
740 propertyType = qmltype.qListTypeId();
742 propertyType = qmltype.typeId();
743 propertyTypeVersion = qmltype.version();
747 propertyFlags.setType(QQmlPropertyData::Flags::QListType);
749 propertyFlags.setType(QQmlPropertyData::Flags::QObjectDerivedType);
753 propertyFlags.setIsWritable(
true);
756 QString propertyName = stringAt(
p->nameIndex);
757 if (!
obj->hasAliasAsDefaultProperty() && propertyIdx ==
obj->indexOfDefaultPropertyOrAlias)
758 cache->_defaultPropertyName = propertyName;
759 cache->appendProperty(propertyName, propertyFlags, effectivePropertyIndex++,
760 propertyType, propertyTypeVersion, effectiveSignalIndex);
762 effectiveSignalIndex++;
769template <
typename ObjectContainer>
773 const quint32 typeId =
param.typeNameIndexOrCommonType();
774 if (
param.indexIsCommonType()) {
786 bool selfReference =
false;
792 if (!qmltype.isComposite()) {
793 const QMetaType typeId =
param.isList() ? qmltype.qListTypeId() : qmltype.typeId();
794 if (!typeId.
isValid() && qmltype.isInlineComponentType()) {
795 const QQmlType qmlType = objectContainer->qmlTypeForComponent(qmltype.elementName());
803 const QQmlType qmlType = objectContainer->qmlTypeForComponent();
807 return param.isList() ? qmltype.qListTypeId() : qmltype.typeId();
810template <
typename ObjectContainer,
typename CompiledObject>
814 const int candidateIndex =
component.namedObjectsInComponentTable()[
i];
815 const CompiledObject &candidate = *objectContainer->objectAt(candidateIndex);
816 if (candidate.objectId() ==
id)
817 return candidateIndex;
822template <
typename ObjectContainer>
840 const ObjectContainer *objectContainer;
843template <
typename ObjectContainer>
846 : propertyCaches(propertyCaches)
847 , objectContainer(objectContainer)
851template <
typename ObjectContainer>
858 bool writable =
false;
859 bool resettable =
false;
860 bool bindable =
false;
862 propertyFlags->setIsAlias(
true);
866 QVarLengthArray<const QV4::CompiledData::Alias *, 4> seenAliases({lastAlias});
870 objectContainer,
component, lastAlias->targetObjectId());
872 const CompiledObject *targetObject = objectContainer->objectAt(targetObjectIndex);
875 auto nextAlias = targetObject->aliasesBegin();
876 for (
uint i = 0;
i < lastAlias->localAliasIndex; ++
i)
880 if (seenAliases.contains(targetAlias)) {
882 QQmlPropertyCacheCreatorBase::tr(
"Cyclic alias"));
885 seenAliases.append(targetAlias);
886 lastAlias = targetAlias;
887 }
while (lastAlias->isAliasToLocalAlias());
889 return propertyDataForAlias(
890 component, *lastAlias,
type, version, propertyFlags, enginePriv);
895 const CompiledObject &targetObject = *objectContainer->objectAt(targetObjectIndex);
899 auto *typeRef = objectContainer->resolvedType(targetObject.inheritedTypeNameIndex);
905 QQmlPropertyCacheCreatorBase::tr(
"Invalid alias target"));
908 const auto referencedType = typeRef->type();
909 if (referencedType.isValid()) {
910 *
type = referencedType.typeId();
911 if (!
type->isValid() && referencedType.isInlineComponentType()) {
912 *
type = objectContainer->qmlTypeForComponent(referencedType.elementName()).typeId();
916 *
type = typeRef->compilationUnit()->metaType();
919 *version = typeRef->version();
921 propertyFlags->setType(QQmlPropertyData::Flags::QObjectDerivedType);
936 *
type =
property->propType();
937 writable =
property->isWritable();
938 resettable =
property->isResettable();
939 bindable =
property->isBindable();
942 propertyFlags->setType(QQmlPropertyData::Flags::QVariantType);
944 propertyFlags->copyPropertyTypeFlags(
property->flags());
957 = objectContainer->resolvedType(targetPropType)) {
958 typeCache = typeRef->typePropertyCache();
963 ? typeCache->property(valueTypeIndex)
965 if (typeProperty ==
nullptr) {
968 QQmlPropertyCacheCreatorBase::tr(
"Invalid alias target"));
970 populateWithPropertyData(typeProperty);
973 populateWithPropertyData(targetProperty);
975 if (valueTypeIndex != -1) {
979 = valueTypeMetaObject->property(valueTypeIndex);
984 resettable = writable && valueTypeMetaProperty.isResettable();
985 writable = writable && valueTypeMetaProperty.isWritable();
987 bindable = valueTypeMetaProperty.isBindable();
992 propertyFlags->setIsWritable(
994 propertyFlags->setIsResettable(resettable);
995 propertyFlags->setIsBindable(bindable);
999template <
typename ObjectContainer>
1003 const CompiledObject &
object = *objectContainer->objectAt(objectIndex);
1004 if (!
object.aliasCount())
1010 int effectiveSignalIndex = propertyCache->signalHandlerIndexCacheStart + propertyCache->propertyIndexCache.size();
1011 int effectivePropertyIndex = propertyCache->propertyIndexCacheStart + propertyCache->propertyIndexCache.size();
1014 auto alias =
object.aliasesBegin();
1015 auto end =
object.aliasesEnd();
1016 for ( ; alias !=
end; ++alias, ++aliasIndex) {
1023 &propertyFlags, enginePriv);
1024 if (
error.isValid())
1027 const QString propertyName = objectContainer->stringAt(alias->
nameIndex());
1029 if (
object.hasAliasAsDefaultProperty() && aliasIndex ==
object.indexOfDefaultPropertyOrAlias)
1030 propertyCache->_defaultPropertyName = propertyName;
1032 propertyCache->
appendProperty(propertyName, propertyFlags, effectivePropertyIndex++,
1033 type, version, effectiveSignalIndex++);
static QByteArray number(int, int base=10)
Returns a byte-array representing the whole number n as text.
typename QLinkedStringHash< QPair< int, QQmlPropertyData * > >::ConstIterator ConstIterator
void append(parameter_type t)
void warning(const QQmlError &)
QQmlTypeLoader typeLoader
The QQmlError class encapsulates a QML error.
void setDescription(const QString &)
Sets the error description.
The QQmlImports class encapsulates one QML document's import statements.
bool resolveType(QQmlTypeLoader *typeLoader, const QHashedStringRef &type, QQmlType *type_return, QTypeRevision *version_return, QQmlImportNamespace **ns_return, QList< QQmlError > *errors=nullptr, QQmlType::RegistrationType registrationType=QQmlType::AnyRegistrationType, bool *typeRecursionDetected=nullptr) const
QQmlPropertyCacheAliasCreator(QQmlPropertyCacheVector *propertyCaches, const ObjectContainer *objectContainer)
QQmlError appendAliasesToPropertyCache(const CompiledObject &component, int objectIndex, QQmlEnginePrivate *enginePriv)
ObjectContainer::CompiledObject CompiledObject
QMetaType metaTypeForParameter(const QV4::CompiledData::ParameterType ¶m, QString *customTypeName=nullptr)
IncrementalResult buildMetaObjectsIncrementally()
typename ObjectContainer::CompiledObject CompiledObject
QString stringAt(int index) const
QQmlEnginePrivate *const enginePrivate
QQmlBindingInstantiationContext m_context
QQmlPendingGroupPropertyBindings * pendingGroupPropertyBindings
~QQmlPropertyCacheCreator()
QQmlError createMetaObject(int objectIndex, const CompiledObject *obj, const QQmlPropertyCache::ConstPtr &baseTypeCache)
typename std::remove_reference< decltype(*(std::declval< CompiledObject >().inlineComponentsBegin()))>::type InlineComponent
const ObjectContainer *const objectContainer
std::vector< icutils::Node >::reverse_iterator nodeIt
QQmlError buildMetaObjectRecursively(int objectIndex, const QQmlBindingInstantiationContext &context, VMEMetaObjectIsRequired isVMERequired)
QQmlError verifyNoICCycle()
QQmlPropertyCacheCreator(QQmlPropertyCacheVector *propertyCaches, QQmlPendingGroupPropertyBindings *pendingGroupPropertyBindings, QQmlEnginePrivate *enginePrivate, const ObjectContainer *objectContainer, const QQmlImports *imports, const QByteArray &typeClassName)
const QQmlImports *const imports
std::vector< InlineComponent > allICs
QQmlPropertyCacheVector * propertyCaches
std::vector< icutils::Node > nodesSorted
QQmlPropertyCache::ConstPtr propertyCacheForObject(const CompiledObject *obj, const QQmlBindingInstantiationContext &context, QQmlError *error) const
bool needsVMEMetaObject(int index) const
void setNeedsVMEMetaObject(int index)
void resetAndResize(int size)
QQmlPropertyCache::ConstPtr at(int index) const
void set(int index, const QQmlPropertyCache::ConstPtr &replacement)
void setOwn(int index, const QQmlPropertyCache::Ptr &replacement)
QQmlPropertyCache::Ptr ownAt(int index) const
void appendProperty(const QString &, QQmlPropertyData::Flags flags, int coreIndex, QMetaType propType, QTypeRevision revision, int notifyIndex)
QMetaType propType() const
static Flags defaultSlotFlags()
static Flags defaultSignalFlags()
static QQmlPropertyIndex fromEncoded(qint32 encodedIndex)
static QString propertyNameToChangedSignalName(QStringView property)
QQmlRefPointer< QQmlTypeData > getType(const QUrl &unNormalizedUrl, Mode mode=PreferSynchronous)
Returns a QQmlTypeData for the specified url.
static QQmlTypeLoader * get(Engine *engine)
QMetaType qListTypeId() const
const_iterator constEnd() const noexcept
const_iterator constFind(const T &value) const
iterator find(const T &value)
\macro QT_RESTRICTED_CAST_FROM_ASCII
bool isEmpty() const noexcept
Returns true if the string has no characters; otherwise returns false.
QString & append(QChar c)
static constexpr QTypeRevision zero()
Produces a QTypeRevision with major and minor version {0}.
QString fileName(ComponentFormattingOptions options=FullyDecoded) const
QCache< int, Employee > cache
[0]
QSet< QString >::iterator it
Combined button and popup list for selecting options.
std::vector< std::vector< Node * > > AdjacencyList
#define Q_DECLARE_TR_FUNCTIONS(context)
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction void DBusFreeFunction return DBusConnection return DBusConnection return const char DBusError return DBusConnection DBusMessage dbus_uint32_t return DBusConnection dbus_bool_t DBusConnection DBusAddWatchFunction DBusRemoveWatchFunction DBusWatchToggledFunction void DBusFreeFunction return DBusConnection DBusDispatchStatusFunction void DBusFreeFunction DBusTimeout return DBusTimeout return DBusWatch return DBusWatch unsigned int return DBusError const DBusError return const DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessageIter * iter
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction function
DBusConnection const char DBusError * error
GLenum GLsizei GLsizei GLint * values
[15]
GLboolean GLboolean GLboolean GLboolean a
[7]
GLenum GLenum GLsizei count
GLuint GLsizei const GLchar * message
GLenum const GLint * param
static qreal component(const QPointF &point, unsigned int i)
QT_BEGIN_NAMESPACE QQmlError qQmlCompileError(const QV4::CompiledData::Location &location, const QString &description)
int objectForId(const ObjectContainer *objectContainer, const CompiledObject &component, int id)
QLatin1StringView QLatin1String
#define QStringLiteral(str)
#define Q_AUTOTEST_EXPORT
QUrl url("example.com")
[constructor-url-reference]
int referencingObjectIndex
QQmlPropertyCache::ConstPtr referencingObjectPropertyCache
const QV4::CompiledData::Binding * instantiatingBinding
bool resolveInstantiatingProperty()
const QQmlPropertyData * instantiatingProperty
QQmlBindingInstantiationContext()
QQmlPropertyCache::ConstPtr instantiatingPropertyCache() const
QString instantiatingPropertyName
void resolveMissingPropertyCaches(QQmlPropertyCacheVector *propertyCaches) const
static bool canCreateClassNameTypeByUrl(const QUrl &url)
static QMetaType listTypeForPropertyType(QV4::CompiledData::CommonType type)
static QByteArray createClassNameTypeByUrl(const QUrl &url)
static QMetaType metaTypeForPropertyType(QV4::CompiledData::CommonType type)
static QAtomicInt Q_AUTOTEST_EXPORT classIndexCounter
static QByteArray createClassNameForInlineComponent(const QUrl &baseUrl, const QString &name)
void setType(Type newType)
const QQmlPropertyData * property(int index) const
Location referenceLocation
@ AliasPointsToPointerObject
qint32_le encodedMetaPropertyIndex
quint32 targetObjectId() const
bool hasFlag(Flag flag) const
bool isAliasToLocalAlias() const
quint32 nameIndex() const