Revision control
++ // Copyright (C) 2022 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 "qqmljsutils_p.h"
++ #include "qqmljstyperesolver_p.h"
++ #include "qqmljsscopesbyid_p.h"
++
++ #include <QtCore/qvarlengtharray.h>
++ #include <QtCore/qdir.h>
++ #include <QtCore/qdiriterator.h>
++
++ #include <algorithm>
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ namespace QQmlJSUtils {
++
++ /*! \internal
++
++ Fully resolves alias \a property and returns the information about the
++ origin, which is not an alias.
++ */
++ template <typename ScopeForId>
++ static ResolvedAlias resolveAlias(ScopeForId scopeForId, const QQmlJSMetaProperty &property,
++ const QQmlJSScope::ConstPtr &owner,
++ const AliasResolutionVisitor &visitor)
++ {
++ Q_ASSERT(property.isAlias());
++ Q_ASSERT(owner);
++
++ ResolvedAlias result{ };
++ result.owner = owner;
++
++ // TODO: one could optimize the generated alias code for aliases pointing to aliases
++ // e.g., if idA.myAlias -> idB.myAlias2 -> idC.myProp, then one could directly generate
++ // idA.myProp as pointing to idC.myProp. // This gets complicated when idB.myAlias is in a different Component than where the
++ // idA.myAlias is defined: scopeForId currently only contains the ids of the current
++ // component and alias resolution on the ids of a different component fails then.
++ if (QQmlJSMetaProperty nextProperty = property; nextProperty.isAlias()) {
++ QQmlJSScope::ConstPtr resultOwner = result.owner;
++ result = ResolvedAlias{ };
++
++ visitor.reset();
++
++ auto aliasExprBits = nextProperty.aliasExpression().split(u'.');
++ // do not crash on invalid aliasexprbits when accessing aliasExprBits[0]
++ if (aliasExprBits.size() < 1)
++ return {};
++
++ // resolve id first:
++ resultOwner = scopeForId(aliasExprBits[0], resultOwner);
++ if (!resultOwner)
++ return {};
++
++ visitor.processResolvedId(resultOwner);
++
++ aliasExprBits.removeFirst(); // Note: for simplicity, remove the <id>
++ result.owner = resultOwner;
++ result.kind = AliasTarget_Object;
++
++ for (const QString &bit : std::as_const(aliasExprBits)) {
++ nextProperty = resultOwner->property(bit);
++ if (!nextProperty.isValid())
++ return {};
++
++ visitor.processResolvedProperty(nextProperty, resultOwner);
++
++ result.property = nextProperty;
++ result.owner = resultOwner;
++ result.kind = AliasTarget_Property;
++
++ resultOwner = nextProperty.type();
++ }
++ }
++
++ return result;
++ }
++
++ ResolvedAlias resolveAlias(const QQmlJSTypeResolver *typeResolver,
++ const QQmlJSMetaProperty &property, const QQmlJSScope::ConstPtr &owner,
++ const AliasResolutionVisitor &visitor)
++ {
++ return resolveAlias(
++ [&](const QString &id, const QQmlJSScope::ConstPtr &referrer) {
++ return typeResolver->typeForId(referrer, id);
++ },
++ property, owner, visitor);
++ }
++
++ ResolvedAlias resolveAlias(const QQmlJSScopesById &idScopes, const QQmlJSMetaProperty &property,
++ const QQmlJSScope::ConstPtr &owner,
++ const AliasResolutionVisitor &visitor)
++ {
++ return resolveAlias(
++ [&](const QString &id, const QQmlJSScope::ConstPtr &referrer) {
++ return idScopes.scope(id, referrer);
++ },
++ property, owner, visitor);
++ }
++
++ std::optional<QQmlJSFixSuggestion> didYouMean(const QString &userInput, QStringList candidates,
++ const QString &filename,
++ const QQmlJS::SourceLocation &location)
++ {
++ QString shortestDistanceWord;
++ int shortestDistance = userInput.size();
++
++ // Most of the time the candidates are keys() from QHash, which means that
++ // running this function in the seemingly same setup might yield different
++ // best cadidate (e.g. imagine a typo 'thing' with candidates 'thingA' vs
++ // 'thingB'). This is especially flaky in e.g. test environment where the
++ // results may differ (even when the global hash seed is fixed!) when
++ // running one test vs the whole test suite (recall platform-dependent
++ // QSKIPs). There could be user-visible side effects as well, so just sort
++ // the candidates to guarantee consistent results
++ std::sort(candidates.begin(), candidates.end());
++
++ for (const QString &candidate : candidates) {
++ /*
++ * Calculate the distance between the userInput and candidate using Damerau–Levenshtein
++ * Roughly based on
++ */
++ QVarLengthArray<int> v0(candidate.size() + 1);
++ QVarLengthArray<int> v1(candidate.size() + 1);
++
++ std::iota(v0.begin(), v0.end(), 0);
++
++ for (qsizetype i = 0; i < userInput.size(); i++) {
++ v1[0] = i + 1;
++ for (qsizetype j = 0; j < candidate.size(); j++) {
++ int deletionCost = v0[j + 1] + 1;
++ int insertionCost = v1[j] + 1;
++ int substitutionCost = userInput[i] == candidate[j] ? v0[j] : v0[j] + 1;
++ v1[j + 1] = std::min({ deletionCost, insertionCost, substitutionCost });
++ }
++ std::swap(v0, v1);
++ }
++
++ int distance = v0[candidate.size()];
++ if (distance < shortestDistance) {
++ shortestDistanceWord = candidate;
++ shortestDistance = distance;
++ }
++ }
++
++ if (shortestDistance
++ < std::min(std::max(userInput.size() / 2, qsizetype(3)), userInput.size())) {
++ return QQmlJSFixSuggestion {
++ u"Did you mean \"%1\"?"_s.arg(shortestDistanceWord),
++ location,
++ { QQmlJSDocumentEdit{ filename, location, shortestDistanceWord } }
++ };
++ } else {
++ return {};
++ }
++ }
++
++ /*! \internal
++
++ Returns a corresponding source directory path for \a buildDirectoryPath
++ Returns empty string on error
++ */
++ std::variant<QString, QQmlJS::DiagnosticMessage>
++ sourceDirectoryPath(const QQmlJSImporter *importer, const QString &buildDirectoryPath)
++ {
++ const auto makeError = [](const QString &msg) {
++ return QQmlJS::DiagnosticMessage { msg, QtWarningMsg, QQmlJS::SourceLocation() };
++ };
++
++ if (!importer->metaDataMapper())
++ return makeError(u"QQmlJSImporter::metaDataMapper() is nullptr"_s);
++
++ // for now, meta data contains just a single entry
++ QQmlJSResourceFileMapper::Filter matchAll { QString(), QStringList(),
++ QQmlJSResourceFileMapper::Directory
++ | QQmlJSResourceFileMapper::Recurse };
++ QQmlJSResourceFileMapper::Entry entry = importer->metaDataMapper()->entry(matchAll);
++ if (!entry.isValid())
++ return makeError(u"Failed to find meta data entry in QQmlJSImporter::metaDataMapper()"_s);
++ if (!buildDirectoryPath.startsWith(entry.filePath)) // assume source directory path already
++ return makeError(u"The module output directory does not match the build directory path"_s);
++
++ QString qrcPath = buildDirectoryPath;
++ qrcPath.remove(0, entry.filePath.size());
++ qrcPath.prepend(entry.resourcePath);
++ qrcPath.remove(0, 1); // remove extra "/"
++
++ const QStringList sourceDirPaths = importer->resourceFileMapper()->filePaths(
++ QQmlJSResourceFileMapper::resourceFileFilter(qrcPath));
++ if (sourceDirPaths.size() != 1) {
++ const QString matchedPaths =
++ sourceDirPaths.isEmpty() ? u"<none>"_s : sourceDirPaths.join(u", ");
++ return makeError(
++ QStringLiteral("QRC path %1 (deduced from %2) has unexpected number of mappings "
++ "(%3). File paths that matched:\n%4")
++ .arg(qrcPath, buildDirectoryPath, QString::number(sourceDirPaths.size()),
++ matchedPaths));
++ }
++ return sourceDirPaths[0];
++ }
++
++ /*! \internal
++
++ Utility method that checks if one of the registers is var, and the other can be
++ efficiently compared to it
++ */
++ bool canStrictlyCompareWithVar(
++ const QQmlJSTypeResolver *typeResolver, const QQmlJSScope::ConstPtr &lhsType,
++ const QQmlJSScope::ConstPtr &rhsType)
++ {
++ Q_ASSERT(typeResolver);
++
++ const QQmlJSScope::ConstPtr varType = typeResolver->varType();
++ const bool leftIsVar = (lhsType == varType);
++ const bool righttIsVar = (rhsType == varType);
++ return leftIsVar != righttIsVar;
++ }
++
++ /*! \internal
++
++ Utility method that checks if one of the registers is qobject, and the other can be
++ efficiently compared to it
++ */
++ bool canCompareWithQObject(
++ const QQmlJSTypeResolver *typeResolver, const QQmlJSScope::ConstPtr &lhsType,
++ const QQmlJSScope::ConstPtr &rhsType)
++ {
++ Q_ASSERT(typeResolver);
++ return (lhsType->isReferenceType()
++ && (rhsType->isReferenceType() || rhsType == typeResolver->nullType()))
++ || (rhsType->isReferenceType()
++ && (lhsType->isReferenceType() || lhsType == typeResolver->nullType()));
++ }
++
++ /*! \internal
++
++ Utility method that checks if both sides are QUrl type. In future, that might be extended to
++ support comparison with other types i.e QUrl vs string
++ */
++ bool canCompareWithQUrl(
++ const QQmlJSTypeResolver *typeResolver, const QQmlJSScope::ConstPtr &lhsType,
++ const QQmlJSScope::ConstPtr &rhsType)
++ {
++ Q_ASSERT(typeResolver);
++ return lhsType == typeResolver->urlType() && rhsType == typeResolver->urlType();
++ }
++
++ /*!
++ \internal
++
++ Utility method that searches qrc files in given folders. Do not use this when the order or
++ selection of the returned qrc files matters.
++ */
++ QStringList resourceFilesFromBuildFolders(const QStringList &buildFolders)
++ {
++ QStringList result;
++ for (const QString &path : buildFolders) {
++ for (auto it : QDirListing{ path, QStringList{ u"*.qrc"_s },
++ QDirListing::IteratorFlag::Recursive
++ | QDirListing::IteratorFlag::FilesOnly
++ | QDirListing::IteratorFlag::IncludeHidden }) {
++ result.append(it.filePath());
++ }
++ }
++ return result;
++ }
++
++ enum FilterType {
++ LocalFileFilter,
++ ResourceFileFilter
++ };
++
++ /*!
++ \internal
++ Finds the qrc folder that contains the "root" qmldir file of a QML Module.
++
++ Contains a heuristic for QML modules without nested-qml-module-with-prefer-feature
++ that tries to find a parent directory that contains a qmldir entry in the qrc.
++
++ \note This assumes that the build folder structure follows the qrc folder structure.
++ */
++ static QQmlJSResourceFileMapper::Entry
++ qmlModuleEntryFromBuildPath(const QQmlJSResourceFileMapper *mapper,
++ const QString &pathInBuildFolder, FilterType type)
++ {
++ const QString cleanPath = QDir::cleanPath(pathInBuildFolder);
++ QStringView directoryPath = cleanPath;
++
++ while (!directoryPath.isEmpty()) {
++ const qsizetype lastSlashIndex = directoryPath.lastIndexOf(u'/');
++ if (lastSlashIndex == -1)
++ return {};
++
++ directoryPath.truncate(lastSlashIndex);
++ const QString qmldirPath = u"%1/qmldir"_s.arg(directoryPath);
++ const QQmlJSResourceFileMapper::Filter qmldirFilter = type == LocalFileFilter
++ ? QQmlJSResourceFileMapper::localFileFilter(qmldirPath)
++ : QQmlJSResourceFileMapper::resourceFileFilter(qmldirPath);
++
++ QQmlJSResourceFileMapper::Entry result = mapper->entry(qmldirFilter);
++ if (result.isValid()) {
++ result.resourcePath.chop(std::char_traits<char>::length("/qmldir"));
++ result.filePath.chop(std::char_traits<char>::length("/qmldir"));
++ return result;
++ }
++ }
++ return {};
++ }
++
++ /*!
++ \internal
++ Obtains the source path from a build path for a QML file via the passed \c mapper.
++
++ We assume here that the QML Module file-structure in the build folder follows the qrc-structure.
++ The build folder contains two qrc mappings:
++ \list
++ \li A mapping from build folder qmldirs to their qrc paths
++ \li A mapping from source folder .qml files to their qrc paths
++ \endlist
++ The build folder path is traveled up until a parent folder was found that contains a qmldir file.
++ The relative path from the parent folder with the qmldir file to the QML file's build path
++ is resolved from the the qrc path of the qmldir obtained from the mapper to obtain the
++ absolute qrc path.
++ The QML file's source path is obtained by mapping the constructed qrc path back to a
++ file system path.
++
++ This works on proper QML modules when using the nested-qml-module-with-prefer-feature
++ from 6.8 and uses a heuristic when the qmldir with the prefer entry is missing.
++ */
++ QString qmlSourcePathFromBuildPath(const QQmlJSResourceFileMapper *mapper,
++ const QString &pathInBuildFolder)
++ {
++ if (!mapper)
++ return pathInBuildFolder;
++
++ // Slice the path the mapper matched against: its entries are absolute and clean.
++ const QString buildPath = QDir::cleanPath(QFileInfo(pathInBuildFolder).absoluteFilePath());
++ const auto qmlModuleEntry = qmlModuleEntryFromBuildPath(mapper, buildPath, LocalFileFilter);
++ if (!qmlModuleEntry.isValid())
++ return pathInBuildFolder;
++ const QString qrcPath = qmlModuleEntry.resourcePath
++ + QStringView(buildPath).sliced(qmlModuleEntry.filePath.size());
++
++ const auto entry = mapper->entry(QQmlJSResourceFileMapper::resourceFileFilter(qrcPath));
++ return entry.isValid()? entry.filePath : pathInBuildFolder;
++ }
++
++ /*!
++ \internal
++ Obtains the source folder path from a build folder QML file path via the passed \c mapper, see also
++ \l QQmlJSUtils::qmlSourcePathFromBuildPath.
++
++ We assume here that the QML Module file-structure in the build folder follows the qrc-structure.
++ The build folder contains two qrc mappings:
++ \list
++ \li A mapping from build folder qmldirs to their qrc paths
++ \li A mapping from source folder .qml files to their qrc paths
++ \endlist
++ The source folder path is first mapped to the .qrc path via the mapper. The .qrc path
++ is traveled up until a parent folder containing a qmldir file was found. The build path
++ is constructed from the qmldir's build path and the relative qrc path of the QML file.
++ */
++ QString qmlBuildPathFromSourcePath(const QQmlJSResourceFileMapper *mapper,
++ const QString &pathInSourceFolder)
++ {
++ if (!mapper)
++ return pathInSourceFolder;
++
++ // A source file may appear under multiple resource paths across different qrc files.
++ // Iterate all entries to find the one that resolves to a module build path.
++ const auto allEntries =
++ mapper->filter(QQmlJSResourceFileMapper::localFileFilter(pathInSourceFolder));
++
++ for (const auto &mapEntry : allEntries) {
++ const QString qrcPath = mapEntry.resourcePath;
++ if (qrcPath.isEmpty())
++ continue;
++
++ const auto moduleBuildEntry =
++ qmlModuleEntryFromBuildPath(mapper, qrcPath, ResourceFileFilter);
++ if (!moduleBuildEntry.isValid())
++ continue;
++
++ return moduleBuildEntry.filePath + qrcPath.sliced(moduleBuildEntry.resourcePath.size());
++ }
++
++ return pathInSourceFolder;
++ }
++
++ /*!
++ \internal
++ Returns the name of \a scope based on \a type.
++ */
++ QString getScopeName(const QQmlJSScope::ConstPtr &scope, QQmlJSScope::ScopeType type)
++ {
++ Q_ASSERT(scope);
++ if (type == QQmlSA::ScopeType::GroupedPropertyScope
++ || type == QQmlSA::ScopeType::AttachedPropertyScope)
++ return scope->internalName();
++
++ if (!scope->isComposite())
++ return scope->internalName();
++
++ if (scope->isInlineComponent() && scope->inlineComponentName().has_value())
++ return scope->inlineComponentName().value();
++
++ if (scope->isFileRootComponent())
++ return QFileInfo(scope->filePath()).baseName();
++
++ return scope->baseTypeName();
++ }
++
++ QString fileSelectorFor(const QQmlJSScope::ConstPtr &scope)
++ {
++ if (!scope)
++ return { };
++ const auto factory = scope.factory();
++ const QString filePath = factory ? factory->filePath() : scope->filePath();
++ QString dir = QFileInfo(filePath).dir().dirName();
++ if (dir.startsWith("+"_L1)) {
++ dir.slice(1);
++ return dir;
++ }
++ return { };
++ }
++
++ } // namespace QQmlJSUtils
++
++ QT_END_NAMESPACE