378 lines
15 KiB
C++
378 lines
15 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2020 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the tools applications of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "checkidentifiers.h"
|
|
|
|
#include <QtQmlCompiler/private/qcoloroutput_p.h>
|
|
|
|
#include <QtCore/qqueue.h>
|
|
#include <QtCore/private/qduplicatetracker_p.h>
|
|
#include <QtCore/qsharedpointer.h>
|
|
#include <stack>
|
|
|
|
static const QStringList unknownBuiltins = {
|
|
QStringLiteral("alias"), // TODO: we cannot properly resolve aliases, yet
|
|
QStringLiteral("QJSValue"), // We cannot say anything intelligent about untyped JS values.
|
|
QStringLiteral("QVariant") // Same for generic variants
|
|
};
|
|
|
|
template<typename Visitor>
|
|
static bool walkRelatedScopes(QQmlJSScope::ConstPtr rootType, const Visitor &visit)
|
|
{
|
|
if (rootType.isNull())
|
|
return false;
|
|
std::stack<QQmlJSScope::ConstPtr> stack;
|
|
QDuplicateTracker<QQmlJSScope::ConstPtr> seenTypes;
|
|
stack.push(rootType);
|
|
|
|
while (!stack.empty()) {
|
|
const auto type = stack.top();
|
|
stack.pop();
|
|
|
|
// If we've seen this type before (can be caused by self attaching types), ignore it
|
|
if (seenTypes.hasSeen(type))
|
|
continue;
|
|
|
|
if (visit(type))
|
|
return true;
|
|
|
|
if (auto attachedType = type->attachedType())
|
|
stack.push(attachedType);
|
|
|
|
if (auto baseType = type->baseType())
|
|
stack.push(baseType);
|
|
|
|
// Push extension type last. It overrides the base type.
|
|
if (auto extensionType = type->extensionType())
|
|
stack.push(extensionType);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CheckIdentifiers::checkMemberAccess(const QVector<FieldMember> &members,
|
|
const QQmlJSScope::ConstPtr &outerScope,
|
|
const QQmlJSMetaProperty *prop) const
|
|
{
|
|
|
|
QStringList expectedNext;
|
|
QString detectedRestrictiveName;
|
|
QString detectedRestrictiveKind;
|
|
|
|
if (prop != nullptr && prop->isList()) {
|
|
detectedRestrictiveKind = QLatin1String("list");
|
|
expectedNext.append(QLatin1String("length"));
|
|
}
|
|
|
|
QQmlJSScope::ConstPtr scope = outerScope;
|
|
for (qsizetype i = 0; i < members.size(); i++) {
|
|
const FieldMember &access = members.at(i);
|
|
|
|
if (scope.isNull()) {
|
|
m_logger->logWarning(
|
|
QString::fromLatin1(
|
|
"Type \"%1\" of base \"%2\" not found when accessing member \"%3\"")
|
|
.arg(detectedRestrictiveKind)
|
|
.arg(detectedRestrictiveName)
|
|
.arg(access.m_name),
|
|
Log_Type, access.m_location);
|
|
return;
|
|
}
|
|
|
|
if (!detectedRestrictiveKind.isEmpty()) {
|
|
if (expectedNext.contains(access.m_name)) {
|
|
expectedNext.clear();
|
|
continue;
|
|
}
|
|
|
|
m_logger->logWarning(
|
|
QLatin1String("\"%1\" is a %2. You cannot access \"%3\" it from here")
|
|
.arg(detectedRestrictiveName)
|
|
.arg(detectedRestrictiveKind)
|
|
.arg(access.m_name),
|
|
Log_Type, access.m_location);
|
|
return;
|
|
}
|
|
|
|
if (unknownBuiltins.contains(scope->internalName()))
|
|
return;
|
|
|
|
const auto property = scope->property(access.m_name);
|
|
if (!property.propertyName().isEmpty()) {
|
|
const auto binding = scope->propertyBinding(access.m_name);
|
|
const QString typeName = access.m_parentType.isEmpty()
|
|
? (binding.hasValue() ? binding.valueTypeName() : property.typeName())
|
|
: access.m_parentType;
|
|
|
|
if (property.isList()) {
|
|
detectedRestrictiveKind = QLatin1String("list");
|
|
detectedRestrictiveName = access.m_name;
|
|
expectedNext.append(QLatin1String("length"));
|
|
continue;
|
|
}
|
|
|
|
if (access.m_parentType.isEmpty()) {
|
|
if (binding.hasValue())
|
|
scope = binding.value();
|
|
else
|
|
scope = property.type();
|
|
|
|
if (scope.isNull()) {
|
|
// Properties should always have a type. Otherwise something
|
|
// was missing from the import already.
|
|
detectedRestrictiveKind = typeName;
|
|
detectedRestrictiveName = access.m_name;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (unknownBuiltins.contains(typeName))
|
|
return;
|
|
|
|
const auto it = m_types.find(typeName);
|
|
if (it == m_types.end()) {
|
|
detectedRestrictiveKind = typeName;
|
|
detectedRestrictiveName = access.m_name;
|
|
scope = QQmlJSScope::ConstPtr();
|
|
} else {
|
|
scope = *it;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (scope->hasMethod(access.m_name))
|
|
return; // Access to property of JS function
|
|
|
|
auto checkEnums = [&](const QQmlJSScope::ConstPtr &scope) {
|
|
if (scope->hasEnumeration(access.m_name)) {
|
|
detectedRestrictiveKind = QLatin1String("enum");
|
|
detectedRestrictiveName = access.m_name;
|
|
expectedNext.append(scope->enumeration(access.m_name).keys());
|
|
return true;
|
|
}
|
|
|
|
if (scope->hasEnumerationKey(access.m_name)) {
|
|
detectedRestrictiveKind = QLatin1String("enum");
|
|
detectedRestrictiveName = access.m_name;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
checkEnums(scope);
|
|
|
|
if (!detectedRestrictiveName.isEmpty())
|
|
continue;
|
|
|
|
QQmlJSScope::ConstPtr rootType;
|
|
if (!access.m_parentType.isEmpty())
|
|
rootType = m_types.value(access.m_parentType);
|
|
else
|
|
rootType = scope;
|
|
|
|
bool typeFound =
|
|
walkRelatedScopes(rootType, [&](QQmlJSScope::ConstPtr type) {
|
|
const auto typeProperties = type->ownProperties();
|
|
const auto typeIt = typeProperties.find(access.m_name);
|
|
if (typeIt != typeProperties.end()) {
|
|
scope = typeIt->type();
|
|
return true;
|
|
}
|
|
|
|
const auto typeMethods = type->ownMethods();
|
|
const auto typeMethodIt = typeMethods.find(access.m_name);
|
|
if (typeMethodIt != typeMethods.end()) {
|
|
detectedRestrictiveName = access.m_name;
|
|
detectedRestrictiveKind = QLatin1String("method");
|
|
return true;
|
|
}
|
|
|
|
return checkEnums(type);
|
|
});
|
|
if (typeFound)
|
|
continue;
|
|
|
|
if (access.m_name.front().isUpper() && scope->scopeType() == QQmlJSScope::QMLScope) {
|
|
// may be an attached type
|
|
|
|
auto it = m_types.find(access.m_name);
|
|
|
|
// Something was found but it wasn't the attached type we were looking for, it could be a prefix
|
|
if (it != m_types.end() && !(*it) && i+1 < members.length()) {
|
|
// See whether this is due to us getting the prefixed property in two accesses (i.e. "T" and "Item")
|
|
// by checking again with a fixed name.
|
|
it = m_types.find(access.m_name + QLatin1Char('.') + members[++i].m_name);
|
|
|
|
if (it == m_types.end() || !(*it) || (*it)->attachedTypeName().isEmpty())
|
|
--i;
|
|
}
|
|
|
|
if (it != m_types.end() && *it && !(*it)->attachedTypeName().isEmpty()) {
|
|
if (const auto attached = (*it)->attachedType()) {
|
|
scope = attached;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_logger->logWarning(QLatin1String("Property \"%1\" not found on type \"%2\"")
|
|
.arg(access.m_name)
|
|
.arg(scope->internalName().isEmpty() ? scope->baseTypeName()
|
|
: scope->internalName()),
|
|
Log_Type, access.m_location);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CheckIdentifiers::operator()(
|
|
const QHash<QString, QQmlJSScope::ConstPtr> &qmlIDs,
|
|
const QHash<QQmlJS::SourceLocation, QQmlJSMetaSignalHandler> &signalHandlers,
|
|
const MemberAccessChains &memberAccessChains, const QQmlJSScope::ConstPtr &root,
|
|
const QString &rootId) const
|
|
{
|
|
// revisit all scopes
|
|
QQueue<QQmlJSScope::ConstPtr> workQueue;
|
|
workQueue.enqueue(root);
|
|
while (!workQueue.empty()) {
|
|
const QQmlJSScope::ConstPtr currentScope = workQueue.dequeue();
|
|
|
|
const auto scopeMemberAccessChains = memberAccessChains[currentScope];
|
|
for (auto memberAccessChain : scopeMemberAccessChains) {
|
|
if (memberAccessChain.isEmpty())
|
|
continue;
|
|
|
|
auto memberAccessBase = memberAccessChain.takeFirst();
|
|
const auto jsId = currentScope->findJSIdentifier(memberAccessBase.m_name);
|
|
if (jsId.has_value() && jsId->kind != QQmlJSScope::JavaScriptIdentifier::Injected) {
|
|
if (memberAccessBase.m_location.end() < jsId->location.begin()) {
|
|
// TODO: Is there a more fitting category?
|
|
m_logger->logWarning(
|
|
QStringLiteral("Variable \"%1\" is used here before its declaration. "
|
|
"The declaration is at %4:%5.")
|
|
.arg(memberAccessBase.m_name)
|
|
.arg(jsId->location.startLine)
|
|
.arg(jsId->location.startColumn),
|
|
Log_Type, memberAccessBase.m_location);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
auto it = qmlIDs.find(memberAccessBase.m_name);
|
|
if (it != qmlIDs.end()) {
|
|
if (!it->isNull()) {
|
|
checkMemberAccess(memberAccessChain, *it);
|
|
continue;
|
|
} else if (!memberAccessChain.isEmpty()) {
|
|
// It could be a qualified type name
|
|
const QString scopedName = memberAccessChain.first().m_name;
|
|
if (scopedName.front().isUpper()) {
|
|
const QString qualified = memberAccessBase.m_name + QLatin1Char('.')
|
|
+ scopedName;
|
|
const auto typeIt = m_types.find(qualified);
|
|
if (typeIt != m_types.end()) {
|
|
memberAccessChain.takeFirst();
|
|
checkMemberAccess(memberAccessChain, *typeIt);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
auto qmlScope = QQmlJSScope::findCurrentQMLScope(currentScope);
|
|
if (qmlScope->hasMethod(memberAccessBase.m_name))
|
|
continue;
|
|
|
|
const auto property = qmlScope->property(memberAccessBase.m_name);
|
|
if (!property.propertyName().isEmpty()) {
|
|
if (memberAccessChain.isEmpty() || unknownBuiltins.contains(property.typeName()))
|
|
continue;
|
|
|
|
const auto binding = qmlScope->propertyBinding(memberAccessBase.m_name);
|
|
if (binding.hasValue()) {
|
|
checkMemberAccess(memberAccessChain, binding.value(), &property);
|
|
} else if (!property.type()) {
|
|
m_logger->logWarning(QString::fromLatin1("Type of property \"%2\" not found")
|
|
.arg(memberAccessBase.m_name),
|
|
Log_Type, memberAccessBase.m_location);
|
|
} else {
|
|
checkMemberAccess(memberAccessChain, property.type(), &property);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
const QString baseName = memberAccessBase.m_name;
|
|
auto typeIt = m_types.find(memberAccessBase.m_name);
|
|
bool baseIsPrefixed = false;
|
|
while (typeIt != m_types.end() && typeIt->isNull()) {
|
|
// This is a namespaced import. Check with the full name.
|
|
if (!memberAccessChain.isEmpty()) {
|
|
auto location = memberAccessBase.m_location;
|
|
memberAccessBase = memberAccessChain.takeFirst();
|
|
memberAccessBase.m_name.prepend(baseName + u'.');
|
|
location.length = memberAccessBase.m_location.offset - location.offset
|
|
+ memberAccessBase.m_location.length;
|
|
memberAccessBase.m_location = location;
|
|
typeIt = m_types.find(memberAccessBase.m_name);
|
|
baseIsPrefixed = true;
|
|
}
|
|
}
|
|
|
|
if (typeIt != m_types.end() && !typeIt->isNull()) {
|
|
checkMemberAccess(memberAccessChain, *typeIt);
|
|
continue;
|
|
}
|
|
|
|
// If we're in a custom parser component (or one of their children) we cannot be sure
|
|
// that this is really an unqualified access. We have to err on the side of producing
|
|
// false negatives for the sake of usability.
|
|
if (qmlScope->isInCustomParserParent()) {
|
|
// We can handle Connections properly
|
|
if (qmlScope->baseType()
|
|
&& qmlScope->baseType()->internalName() != u"QQmlConnections"_qs)
|
|
continue;
|
|
}
|
|
|
|
const auto location = memberAccessBase.m_location;
|
|
|
|
if (baseIsPrefixed) {
|
|
m_logger->logWarning(QLatin1String("Type not found in namespace"), Log_Type,
|
|
location);
|
|
}
|
|
|
|
Q_UNUSED(signalHandlers)
|
|
Q_UNUSED(rootId)
|
|
}
|
|
const auto childScopes = currentScope->childScopes();
|
|
for (auto const &childScope : childScopes)
|
|
workQueue.enqueue(childScope);
|
|
}
|
|
}
|