Revision control
++ // Copyright (C) 2019 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
++ // Qt-Security score:significant
++
++ #include "qqmltyperegistrarutils_p.h"
++ #include "qqmltypesclassdescription_p.h"
++
++ #include "qanystringviewutils_p.h"
++ #include "qmetatypesjsonprocessor_p.h"
++ #include "qqmltyperegistrarconstants_p.h"
++
++ #include <QtCore/qcborarray.h>
++ #include <QtCore/qcbormap.h>
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++ using namespace Constants;
++ using namespace Constants::MetatypesDotJson;
++ using namespace Constants::MetatypesDotJson::Qml;
++ using namespace QAnyStringViewUtils;
++
++ template<typename Container>
++ static void collectExtraVersions(const Container &items, QList<QTypeRevision> &extraVersions)
++ {
++ for (const auto &obj : items) {
++ if (obj.revision.isValid() && !extraVersions.contains(obj.revision))
++ extraVersions.append(obj.revision);
++ }
++ }
++
++ struct Compare {
++ bool operator()(const QAnyStringView &typeName, const MetaType &type) const
++ {
++ return typeName < type.qualifiedClassName();
++ }
++
++ bool operator()(const MetaType &type, const QAnyStringView &typeName) const
++ {
++ return type.qualifiedClassName() < typeName;
++ }
++ };
++
++ FoundType::FoundType(const MetaType &single, FoundType::Origin origin)
++ {
++ if (single.inputFile().isEmpty()) {
++ javaScript = single;
++ javaScriptOrigin = origin;
++ } else {
++ native = single;
++ nativeOrigin = origin;
++ }
++ }
++
++ MetaType FoundType::select(const MetaType &category, QAnyStringView relation) const
++ {
++ if (category.inputFile().isEmpty()) {
++ if (javaScript.isEmpty()) {
++ warning(category)
++ << relation << "type of" << category.qualifiedClassName()
++ << "is not a JavaScript type";
++ }
++ return javaScript;
++ }
++
++ if (native.isEmpty()) {
++ warning(category)
++ << relation << "of" << category.qualifiedClassName()
++ << "is not a native type";
++ }
++ return native;
++ }
++
++ FoundType QmlTypesClassDescription::findType(
++ const QList<MetaType> &types, const QList<MetaType> &foreign,
++ const QAnyStringView &name, const QList<QAnyStringView> &namespaces)
++ {
++ const auto tryFindType = [&](QAnyStringView qualifiedName) -> FoundType {
++ FoundType result;
++ for (const QList<MetaType> &t : {types, foreign}) {
++ const auto [first, last] = std::equal_range(
++ t.begin(), t.end(), qualifiedName, Compare());
++ for (auto it = first; it != last; ++it) {
++ Q_ASSERT(it->qualifiedClassName() == qualifiedName);
++
++ if (it->inputFile().isEmpty()) {
++ if (result.javaScript.isEmpty()) {
++ result.javaScript = *it;
++ result.javaScriptOrigin = (&t == &types)
++ ? FoundType::OwnTypes
++ : FoundType::ForeignTypes;
++ } else {
++ warning(result.javaScript)
++ << "Multiple JavaScript types called" << qualifiedName << "found!";
++ }
++ } else if (result.native.isEmpty()) {
++ result.native = *it;
++ result.nativeOrigin = (&t == &types)
++ ? FoundType::OwnTypes
++ : FoundType::ForeignTypes;
++ } else {
++ warning(result.native)
++ << "Multiple C++ types called" << qualifiedName << "found!\n"
++ << "(other occurrence in :"
++ << it->inputFile() << ":" << it->lineNumber() << ")\n"
++ << "This violates the One Definition Rule!";
++ }
++ }
++ }
++
++ return result;
++ };
++
++ if (startsWith(name, QLatin1String("::")))
++ return tryFindType(name.mid(2));
++
++ QString qualified;
++ for (int i = 0, end = namespaces.length(); i != end; ++i) {
++ for (int j = 0; j < end - i; ++j) {
++ namespaces[j].visit([&](auto data) { qualified.append(data); });
++ qualified.append(QLatin1String("::"));
++ }
++ name.visit([&](auto data) { qualified.append(data); });
++ if (const FoundType found = tryFindType(qualified))
++ return found;
++
++ qualified.truncate(0);
++ }
++
++ return tryFindType(name);
++ }
++
++ void QmlTypesClassDescription::collectSuperClasses(
++ const MetaType &classDef, const QList<MetaType> &types,
++ const QList<MetaType> &foreign, CollectMode mode, QTypeRevision defaultRevision)
++ {
++ const QList<QAnyStringView> namespaces = MetaTypesJsonProcessor::namespaces(classDef);
++ QAnyStringView superClassCandidate;
++ for (const BaseType &superObject : std::as_const(classDef.superClasses())) {
++ if (superObject.access == Access::Public) {
++ const QAnyStringView superName = superObject.name;
++
++ const CollectMode superMode = (mode == TopLevel) ? SuperClass : RelatedType;
++ if (const FoundType found = findType(types, foreign, superName, namespaces)) {
++ const MetaType other = found.select(classDef, "Base");
++ collect(other, types, foreign, superMode, defaultRevision);
++ if (mode == TopLevel && superClass.isEmpty())
++ superClass = other.qualifiedClassName();
++ } else {
++ // If we cannot resolve anything but find a correctly formed superObject,
++ // we can at least populate the name. Further tooling might locate the type
++ // in a different module.
++ superClassCandidate = superName;
++ }
++ }
++ }
++
++ if (mode == TopLevel && superClass.isEmpty())
++ superClass = superClassCandidate;
++ }
++
++ void QmlTypesClassDescription::collectInterfaces(const MetaType &classDef)
++ {
++ for (const Interface &iface : classDef.ifaces())
++ implementsInterfaces << interfaceName(iface);
++ }
++
++ void QmlTypesClassDescription::handleRegisterEnumClassesUnscoped(
++ const MetaType &classDef, QAnyStringView value)
++ {
++ if (value == S_FALSE)
++ enforcesScopedEnums = true;
++ else if (value == S_TRUE)
++ warning(classDef) << "Setting RegisterEnumClassesUnscoped to true has no effect.";
++ else
++ warning(classDef) << "Unrecognized value for RegisterEnumClassesUnscoped:" << value;
++ }
++
++ void QmlTypesClassDescription::collectLocalAnonymous(
++ const MetaType &classDef, const QList<MetaType> &types,
++ const QList<MetaType> &foreign, QTypeRevision defaultRevision)
++ {
++ file = classDef.inputFile();
++ lineNumber = classDef.lineNumber();
++
++ resolvedClass = classDef;
++ className = classDef.qualifiedClassName();
++
++ switch (classDef.kind()) {
++ case MetaType::Kind::Object:
++ accessSemantics = DotQmltypes::S_REFERENCE;
++ break;
++ case MetaType::Kind::Gadget:
++ accessSemantics = DotQmltypes::S_VALUE;
++ break;
++ case MetaType::Kind::Namespace:
++ case MetaType::Kind::Unknown:
++ accessSemantics = DotQmltypes::S_NONE;
++ break;
++ }
++
++ for (const ClassInfo &obj : classDef.classInfos()) {
++ if (obj.name == S_DEFAULT_PROPERTY)
++ defaultProp = obj.value;
++ else if (obj.name == S_PARENT_PROPERTY)
++ parentProp = obj.value;
++ else if (obj.name == S_REGISTER_ENUM_CLASSES_UNSCOPED)
++ handleRegisterEnumClassesUnscoped(classDef, obj.value);
++ }
++
++ collectInterfaces(classDef);
++ collectSuperClasses(classDef, types, foreign, TopLevel, defaultRevision);
++ }
++
++ void QmlTypesClassDescription::collect(
++ const MetaType &classDef, const QList<MetaType> &types,
++ const QList<MetaType> &foreign, CollectMode mode, QTypeRevision defaultRevision)
++ {
++ if (file.isEmpty()) {
++ file = classDef.inputFile();
++ lineNumber = classDef.lineNumber();
++ }
++
++ const QAnyStringView classDefName = classDef.className();
++ const QList<QAnyStringView> namespaces = MetaTypesJsonProcessor::namespaces(classDef);
++
++ QAnyStringView foreignTypeName;
++ bool foreignIsNamespace = false;
++ bool isConstructible = false;
++ for (const ClassInfo &obj : classDef.classInfos()) {
++ const QAnyStringView name = obj.name;
++ const QAnyStringView value = obj.value;
++
++ if (name == S_DEFAULT_PROPERTY) {
++ if (mode != RelatedType && defaultProp.isEmpty())
++ defaultProp = value;
++ continue;
++ }
++
++ if (name == S_PARENT_PROPERTY) {
++ if (mode != RelatedType && parentProp.isEmpty())
++ parentProp = value;
++ continue;
++ }
++
++ if (name == S_REGISTER_ENUM_CLASSES_UNSCOPED) {
++ if (mode != RelatedType)
++ handleRegisterEnumClassesUnscoped(classDef, value);
++ continue;
++ }
++
++ if (name == S_ADDED_IN_VERSION) {
++ const QTypeRevision revision = handleInMinorVersion(
++ QTypeRevision::fromEncodedVersion(toInt(value)),
++ defaultRevision.majorVersion());
++ revisions.append(revision);
++ if (mode == TopLevel)
++ addedInRevision = revision;
++ continue;
++ }
++
++ if (name == S_EXTRA_VERSION) {
++ const QTypeRevision revision = handleInMinorVersion(
++ QTypeRevision::fromEncodedVersion(toInt(value)),
++ defaultRevision.majorVersion());
++ revisions.append(revision);
++ continue;
++ }
++
++ if (mode != TopLevel)
++ continue;
++
++ if (name == S_REMOVED_IN_VERSION) {
++ removedInRevision = handleInMinorVersion(
++ QTypeRevision::fromEncodedVersion(toInt(value)),
++ defaultRevision.majorVersion());
++ continue;
++ }
++
++ // These only apply to the original class
++ if (name == S_ELEMENT) {
++ if (value == S_AUTO)
++ elementNames.append(classDefName);
++ else if (value != S_ANONYMOUS)
++ elementNames.append(value);
++ } else if (name == S_CREATABLE) {
++ isCreatable = (value != S_FALSE);
++ } else if (name == S_CREATION_METHOD) {
++ isStructured = (value == S_STRUCTURED);
++ isConstructible = isStructured || (value == S_CONSTRUCT);
++ } else if (name == S_ATTACHED) {
++ if (const FoundType attached = collectRelated(
++ value, types, foreign, defaultRevision, namespaces)) {
++ attachedType = attached.select(classDef, "Attached").qualifiedClassName();
++ }
++ } else if (name == S_EXTENDED) {
++ if (const FoundType extension = collectRelated(
++ value, types, foreign, defaultRevision, namespaces)) {
++ javaScriptExtensionType = extension.javaScript.qualifiedClassName();
++ nativeExtensionType = extension.native.qualifiedClassName();
++ }
++ if (value == classDefName)
++ isSelfExtension = true;
++ } else if (name == S_EXTENSION_IS_JAVA_SCRIPT) {
++ if (value == S_TRUE)
++ extensionIsJavaScript = true;
++ } else if (name == S_EXTENSION_IS_NAMESPACE) {
++ if (value == S_TRUE)
++ extensionIsNamespace = true;
++ } else if (name == S_SEQUENCE) {
++ if (const FoundType element = collectRelated(
++ value, types, foreign, defaultRevision, namespaces)) {
++ sequenceValueType = element.select(classDef, "Sequence value").qualifiedClassName();
++ } else {
++ // TODO: get rid of this once we have JSON data for the builtins.
++ sequenceValueType = value;
++ }
++ } else if (name == S_SINGLETON) {
++ if (value == S_TRUE)
++ isSingleton = true;
++ } else if (name == S_FOREIGN) {
++ foreignTypeName = value;
++ } else if (name == S_FOREIGN_IS_NAMESPACE) {
++ foreignIsNamespace = (value == S_TRUE);
++ } else if (name == S_PRIMITIVE_ALIAS) {
++ primitiveAliases.append(value);
++ } else if (name == S_ROOT) {
++ isRootClass = (value == S_TRUE);
++ } else if (name == S_HAS_CUSTOM_PARSER) {
++ if (value == S_TRUE)
++ hasCustomParser = true;
++ } else if (name == S_DEFERRED_PROPERTY_NAMES) {
++ deferredNames = split(value, QLatin1StringView(","));
++ } else if (name == S_IMMEDIATE_PROPERTY_NAMES) {
++ immediateNames = split(value, QLatin1StringView(","));
++ }
++ }
++
++ if (addedInRevision.isValid() && !elementNames.isEmpty())
++ revisions.append(addedInRevision);
++
++ // If the local type is a namespace the result can only be a namespace,
++ // no matter what the foreign type is.
++ const bool isNamespace = foreignIsNamespace || classDef.kind() == MetaType::Kind::Namespace;
++
++ MetaType resolved = classDef;
++ if (!foreignTypeName.isEmpty()) {
++ // We can re-use a type with own QML.* macros as target of QML.Foreign
++ if (const FoundType found = findType(foreign, types, foreignTypeName, namespaces)) {
++ resolved = found.select(classDef, "Foreign");
++
++ // Default properties and enum classes are always local.
++ defaultProp = {};
++ enforcesScopedEnums = false;
++
++ // Foreign type can have a default property or an attached type,
++ // or RegisterEnumClassesUnscoped classinfo.
++ for (const ClassInfo &obj : resolved.classInfos()) {
++ const QAnyStringView foreignName = obj.name;
++ const QAnyStringView foreignValue = obj.value;
++ if (defaultProp.isEmpty() && foreignName == S_DEFAULT_PROPERTY) {
++ defaultProp = foreignValue;
++ } else if (parentProp.isEmpty() && foreignName == S_PARENT_PROPERTY) {
++ parentProp = foreignValue;
++ } else if (foreignName == S_REGISTER_ENUM_CLASSES_UNSCOPED) {
++ handleRegisterEnumClassesUnscoped(resolved, foreignValue);
++ } else if (foreignName == S_ATTACHED) {
++ if (const FoundType attached = collectRelated(
++ foreignValue, types, foreign, defaultRevision, namespaces)) {
++ attachedType = attached.select(resolved, "Attached").qualifiedClassName();
++ }
++ } else if (foreignName == S_EXTENDED) {
++ if (const FoundType extension = collectRelated(
++ foreignValue, types, foreign, defaultRevision, namespaces)) {
++ nativeExtensionType = extension.native.qualifiedClassName();
++ javaScriptExtensionType = extension.javaScript.qualifiedClassName();
++ }
++ } else if (foreignName == S_EXTENSION_IS_JAVA_SCRIPT) {
++ if (foreignValue == S_TRUE)
++ extensionIsJavaScript = true;
++ } else if (foreignName == S_EXTENSION_IS_NAMESPACE) {
++ if (foreignValue == S_TRUE)
++ extensionIsNamespace = true;
++ } else if (foreignName == S_SEQUENCE) {
++ if (const FoundType element = collectRelated(
++ foreignValue, types, foreign, defaultRevision, namespaces)) {
++ sequenceValueType
++ = element.select(resolved, "Sequence value").qualifiedClassName();
++ }
++ }
++ }
++ if (mode == TopLevel) {
++ resolvedFile = resolved.inputFile();
++ lineNumberInResolvedFile = resolved.lineNumber();
++ }
++ } else {
++ className = foreignTypeName;
++ resolved = MetaType();
++ }
++ }
++
++ if (!resolved.isEmpty()) {
++ if (mode == RelatedType || !elementNames.isEmpty()) {
++ collectExtraVersions(resolved.properties(), revisions);
++ collectExtraVersions(resolved.methods(), revisions);
++ collectExtraVersions(resolved.sigs(), revisions);
++ }
++
++ collectSuperClasses(resolved, types, foreign, mode, defaultRevision);
++ }
++
++ if (mode != TopLevel)
++ return;
++
++ if (!resolved.isEmpty())
++ collectInterfaces(resolved);
++
++ if (!addedInRevision.isValid()) {
++ addedInRevision = defaultRevision;
++ }
++ if (addedInRevision <= defaultRevision
++ && (!removedInRevision.isValid() || defaultRevision < removedInRevision)) {
++ revisions.append(defaultRevision);
++ }
++
++ std::sort(revisions.begin(), revisions.end());
++ const auto end = std::unique(revisions.begin(), revisions.end());
++ revisions.erase(QList<QTypeRevision>::const_iterator(end), revisions.constEnd());
++
++ resolvedClass = resolved;
++ if (className.isEmpty() && !resolved.isEmpty())
++ className = resolved.qualifiedClassName();
++
++ if (!sequenceValueType.isEmpty()) {
++ isCreatable = false;
++ accessSemantics = DotQmltypes::S_SEQUENCE;
++ } else if (isNamespace) {
++ isCreatable = false;
++ accessSemantics = DotQmltypes::S_NONE;
++ } else if (resolved.kind() == MetaType::Kind::Object) {
++ accessSemantics = DotQmltypes::S_REFERENCE;
++ } else {
++ isCreatable = isConstructible;
++
++ if (resolved.isEmpty()) {
++ if (elementNames.isEmpty()) {
++ // If no resolved, we generally assume it's a value type defined by the
++ // foreign/extended trick.
++ accessSemantics = DotQmltypes::S_VALUE;
++ }
++
++ for (auto elementName = elementNames.begin(); elementName != elementNames.end();) {
++ if (elementName->isEmpty() || elementName->front().isLower()) {
++ // If no resolved, we generally assume it's a value type defined by the
++ // foreign/extended trick.
++ accessSemantics = DotQmltypes::S_VALUE;
++ ++elementName;
++ } else {
++ // Objects and namespaces always have metaobjects and therefore classDefs.
++ // However, we may not be able to resolve the metaobject at compile time. See
++ // the "Invisible" test case. In that case, we must not assume anything about
++ // access semantics.
++
++ warning(classDef)
++ << "Refusing to generate non-lowercase name"
++ << *elementName << "for unknown foreign type";
++ elementName = elementNames.erase(elementName);
++
++ if (elementNames.isEmpty()) {
++ // Make it completely inaccessible.
++ // We cannot get enums from anonymous types after all.
++ accessSemantics = DotQmltypes::S_NONE;
++ }
++ }
++ }
++ } else if (resolved.kind() == MetaType::Kind::Gadget) {
++ accessSemantics = DotQmltypes::S_VALUE;
++ } else {
++ accessSemantics = DotQmltypes::S_NONE;
++ }
++ }
++ }
++
++ FoundType QmlTypesClassDescription::collectRelated(
++ QAnyStringView related, const QList<MetaType> &types, const QList<MetaType> &foreign,
++ QTypeRevision defaultRevision, const QList<QAnyStringView> &namespaces)
++ {
++ if (FoundType other = findType(types, foreign, related, namespaces)) {
++ if (!other.native.isEmpty())
++ collect(other.native, types, foreign, RelatedType, defaultRevision);
++ if (!other.javaScript.isEmpty())
++ collect(other.javaScript, types, foreign, RelatedType, defaultRevision);
++ return other;
++ }
++ return FoundType();
++ }
++
++ struct UsingCompare {
++ bool operator()(const UsingDeclaration &a, QAnyStringView b) const
++ {
++ return a.alias < b;
++ }
++
++ bool operator()(QAnyStringView a, const UsingDeclaration &b) const
++ {
++ return a < b.alias;
++ }
++ };
++
++ ResolvedTypeAlias::ResolvedTypeAlias(
++ QAnyStringView alias, const QList<UsingDeclaration> &usingDeclarations)
++ : type(alias)
++ {
++ handleVoid();
++ if (type.isEmpty())
++ return;
++
++ handleList();
++
++ if (!isList) {
++ handlePointer();
++ handleConst();
++ }
++
++ while (true) {
++ const auto usingDeclaration = std::equal_range(
++ usingDeclarations.begin(), usingDeclarations.end(), type, UsingCompare());
++ if (usingDeclaration.first == usingDeclaration.second)
++ break;
++
++ type = usingDeclaration.first->original;
++ handleVoid();
++ if (type.isEmpty())
++ return;
++
++ if (isPointer) {
++ handleConst();
++ continue;
++ }
++
++ if (!isList) {
++ handleList();
++ if (!isList) {
++ handlePointer();
++ handleConst();
++ }
++ }
++ }
++ }
++
++ void ResolvedTypeAlias::handleVoid()
++ {
++ if (!isPointer && type == "void")
++ type = "";
++ }
++
++ void ResolvedTypeAlias::handleList()
++ {
++ for (QLatin1StringView list : {"QQmlListProperty<"_L1, "QList<"_L1}) {
++ if (!startsWith(type, list) || type.back() != '>'_L1)
++ continue;
++
++ const int listSize = list.size();
++ const QAnyStringView elementType = trimmed(type.mid(listSize, type.size() - listSize - 1));
++
++ // QQmlListProperty internally constructs the pointer. Passing an explicit '*' will
++ // produce double pointers. QList is only for value types. We can't handle QLists
++ // of pointers (unless specially registered, but then they're not isList).
++ if (elementType.back() == '*'_L1)
++ continue;
++
++ isList = true;
++ type = elementType;
++ return;
++ }
++ }
++
++ void ResolvedTypeAlias::handlePointer()
++ {
++ if (type.back() == '*'_L1) {
++ isPointer = true;
++ type = type.chopped(1);
++ while (type.back().isSpace())
++ type.chop(1);
++ }
++ }
++
++ void ResolvedTypeAlias::handleConst()
++ {
++ if (startsWith(type, "const "_L1)) {
++ isConstant = true;
++ type = type.sliced(strlen("const "));
++ }
++ }
++
++ QT_END_NAMESPACE