feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
1988d891981f0bc9f59f07a36f0e9b02f1450338
qt-creator/tests/auto/cplusplus/findusages/tst_findusages.cpp
Christian Kandeler 1988d89198 CPlusPlus: Check for static member functions in FindUsages 
Static member functions cannot modify the object and therefore must not
be reported as writable references.
Note that this does not have an effect yet, as the function type lacks
information about the "static" specifier.

Task-number: QTCREATORBUG-24894
Change-Id: Ib04a17864a0ca5b7610579a2f5efbcfde257e08a
Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2020-11-09 09:51:08 +00:00

2251 lines
70 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** 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.
**
****************************************************************************/
#include "../cplusplus_global.h"
#include <QtTest>
#include <QObject>
#include <QList>
#include <cplusplus/AST.h>
#include <cplusplus/ASTVisitor.h>
#include <cplusplus/CppDocument.h>
#include <cplusplus/FindUsages.h>
#include <cplusplus/Literals.h>
#include <cplusplus/LookupContext.h>
#include <cplusplus/Name.h>
#include <cplusplus/Overview.h>
#include <cplusplus/ResolveExpression.h>
#include <cplusplus/Symbols.h>
#include <cplusplus/TranslationUnit.h>
//TESTED_COMPONENT=src/libs/cplusplus
using namespace CPlusPlus;
class CollectNames: public ASTVisitor
{
public:
CollectNames(TranslationUnit *xUnit): ASTVisitor(xUnit) {}
QList<NameAST*> operator()(const char *name) {
_name = name;
_exprs.clear();
accept(translationUnit()->ast());
return _exprs;
}
virtual bool preVisit(AST *ast) {
if (NameAST *nameAst = ast->asName())
if (!qstrcmp(_name, nameAst->name->identifier()->chars()))
_exprs.append(nameAst);
return true;
}
private:
QList<NameAST*> _exprs;
const char *_name;
};
class tst_FindUsages: public QObject
{
Q_OBJECT
private:
void dump(const QList<Usage> &usages) const;
private Q_SLOTS:
void inlineMethod();
void lambdaCaptureByValue();
void lambdaCaptureByReference();
void shadowedNames_1();
void shadowedNames_2();
void staticVariables();
void functionNameFoundInArguments();
void memberFunctionFalsePositives_QTCREATORBUG2176();
void resolveTemplateConstructor();
void templateConstructorVsCallOperator();
// Qt keywords
void qproperty_1();
// Objective-C
void objc_args();
// void objc_methods();
// void objc_fields();
// void objc_classes();
// templates
void instantiateTemplateWithNestedClass();
void operatorAsteriskOfNestedClassOfTemplateClass_QTCREATORBUG9006();
void operatorArrowOfNestedClassOfTemplateClass_QTCREATORBUG9005();
void templateClassParameters();
void templateClass_className();
void templateFunctionParameters();
void anonymousClass_QTCREATORBUG8963();
void anonymousClass_QTCREATORBUG11859();
void using_insideGlobalNamespace();
void using_insideNamespace();
void using_insideFunction();
void templatedFunction_QTCREATORBUG9749();
void usingInDifferentNamespace_QTCREATORBUG7978();
void unicodeIdentifier();
void inAlignas();
void memberAccessAsTemplate();
void variadicFunctionTemplate();
void typeTemplateParameterWithDefault();
void resolveOrder_for_templateFunction_vs_function();
void templateArrowOperator_with_defaultType();
void templateSpecialization_with_IntArgument();
void templateSpecialization_with_BoolArgument();
void templatePartialSpecialization();
void templatePartialSpecialization_2();
void template_SFINAE_1();
void variableTemplateInExpression();
void variadicMacros();
void writableRefs();
};
void tst_FindUsages::dump(const QList<Usage> &usages) const
{
QTextStream err(stderr, QIODevice::WriteOnly);
err << "DEBUG : " << usages.size() << " usages:" << Qt::endl;
foreach (const Usage &usage, usages) {
err << "DEBUG : " << usage.path << ":" << usage.line << ":" << usage.col << ":"
<< usage.len << ":" << usage.lineText << Qt::endl;
}
}
void tst_FindUsages::inlineMethod()
{
const QByteArray src = "\n"
"class Tst {\n"
" int method(int arg) {\n"
" return arg;\n"
" }\n"
"};\n";
Document::Ptr doc = Document::create("inlineMethod");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 1);
Snapshot snapshot;
snapshot.insert(doc);
Class *tst = doc->globalSymbolAt(0)->asClass();
QVERIFY(tst);
QCOMPARE(tst->memberCount(), 1);
Function *method = tst->memberAt(0)->asFunction();
QVERIFY(method);
QCOMPARE(method->argumentCount(), 1);
Argument *arg = method->argumentAt(0)->asArgument();
QVERIFY(arg);
QCOMPARE(arg->identifier()->chars(), "arg");
FindUsages findUsages(src, doc, snapshot);
findUsages(arg);
QCOMPARE(findUsages.usages().size(), 2);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Read);
QCOMPARE(findUsages.references().size(), 2);
}
void tst_FindUsages::lambdaCaptureByValue()
{
const QByteArray src = "\n"
"void f() {\n"
" int test;\n"
" [test] { ++test; };\n"
"}\n";
Document::Ptr doc = Document::create("lambdaCaptureByValue");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 1);
Snapshot snapshot;
snapshot.insert(doc);
Function *f = doc->globalSymbolAt(0)->asFunction();
QVERIFY(f);
QCOMPARE(f->memberCount(), 1);
Block *b = f->memberAt(0)->asBlock();
QCOMPARE(b->memberCount(), 2);
Declaration *d = b->memberAt(0)->asDeclaration();
QVERIFY(d);
QCOMPARE(d->name()->identifier()->chars(), "test");
FindUsages findUsages(src, doc, snapshot);
findUsages(d);
QCOMPARE(findUsages.usages().size(), 3);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Read);
}
void tst_FindUsages::lambdaCaptureByReference()
{
const QByteArray src = "\n"
"void f() {\n"
" int test;\n"
" [&test] { ++test; };\n"
"}\n";
Document::Ptr doc = Document::create("lambdaCaptureByReference");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 1);
Snapshot snapshot;
snapshot.insert(doc);
Function *f = doc->globalSymbolAt(0)->asFunction();
QVERIFY(f);
QCOMPARE(f->memberCount(), 1);
Block *b = f->memberAt(0)->asBlock();
QCOMPARE(b->memberCount(), 2);
Declaration *d = b->memberAt(0)->asDeclaration();
QVERIFY(d);
QCOMPARE(d->name()->identifier()->chars(), "test");
FindUsages findUsages(src, doc, snapshot);
findUsages(d);
QCOMPARE(findUsages.usages().size(), 3);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
QEXPECT_FAIL(nullptr, "parser does not record capture type", Continue);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Write);
}
void tst_FindUsages::shadowedNames_1()
{
const QByteArray src = "\n"
"int a();\n"
"struct X{ int a(); };\n"
"int X::a() {}\n"
"void f(X x) { x.a(); }\n"
"void g() { a(); }\n"
;
Document::Ptr doc = Document::create("shadowedNames_1");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 5);
Snapshot snapshot;
snapshot.insert(doc);
Declaration *d = doc->globalSymbolAt(0)->asDeclaration();
QVERIFY(d);
QCOMPARE(d->name()->identifier()->chars(), "a");
FindUsages findUsages(src, doc, snapshot);
findUsages(d);
QCOMPARE(findUsages.usages().size(), 2);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
}
void tst_FindUsages::shadowedNames_2()
{
const QByteArray src = "\n"
"int a();\n"
"struct X{ int a(); };\n"
"int X::a() {}\n"
"void f(X x) { x.a(); }\n"
"void g() { a(); }\n";
Document::Ptr doc = Document::create("shadowedNames_2");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 5);
Snapshot snapshot;
snapshot.insert(doc);
Class *c = doc->globalSymbolAt(1)->asClass();
QVERIFY(c);
QCOMPARE(c->name()->identifier()->chars(), "X");
QCOMPARE(c->memberCount(), 1);
Declaration *d = c->memberAt(0)->asDeclaration();
QVERIFY(d);
QCOMPARE(d->name()->identifier()->chars(), "a");
FindUsages findUsages(src, doc, snapshot);
findUsages(d);
QCOMPARE(findUsages.usages().size(), 3);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Other);
}
void tst_FindUsages::staticVariables()
{
const QByteArray src = "\n"
"struct Outer\n"
"{\n"
" static int Foo;\n"
" struct Inner\n"
" {\n"
" Outer *outer;\n"
" void foo();\n"
" };\n"
"};\n"
"\n"
"int Outer::Foo = 42;\n"
"\n"
"void Outer::Inner::foo()\n"
"{\n"
" Foo = 7;\n"
" Outer::Foo = 7;\n"
" outer->Foo = 7;\n"
"}\n"
;
Document::Ptr doc = Document::create("staticVariables");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 3);
Snapshot snapshot;
snapshot.insert(doc);
Class *c = doc->globalSymbolAt(0)->asClass();
QVERIFY(c);
QCOMPARE(c->name()->identifier()->chars(), "Outer");
QCOMPARE(c->memberCount(), 2);
Declaration *d = c->memberAt(0)->asDeclaration();
QVERIFY(d);
QCOMPARE(d->name()->identifier()->chars(), "Foo");
FindUsages findUsages(src, doc, snapshot);
findUsages(d);
QCOMPARE(findUsages.usages().size(), 5);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Initialization);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Write);
QCOMPARE(findUsages.usages().at(3).type, Usage::Type::Write);
QCOMPARE(findUsages.usages().at(4).type, Usage::Type::Write);
}
void tst_FindUsages::functionNameFoundInArguments()
{
const QByteArray src =
R"(
void bar(); // call find usages for bar from here. This is 1st result
void foo(int bar); // should not be found
void foo(int bar){} // should not be found
void foo2(int b=bar()); // 2nd result
void foo2(int b=bar()){} // 3rd result
)";
Document::Ptr doc = Document::create("functionNameFoundInArguments");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount() >= 1);
Symbol *s = doc->globalSymbolAt(0);
QCOMPARE(s->name()->identifier()->chars(), "bar");
Snapshot snapshot;
snapshot.insert(doc);
FindUsages find(src, doc, snapshot);
find(s);
QCOMPARE(find.usages().size(), 3);
QCOMPARE(find.usages()[0].type, Usage::Type::Declaration);
QCOMPARE(find.usages()[0].line, 1);
QCOMPARE(find.usages()[0].col, 5);
QCOMPARE(find.usages()[1].type, Usage::Type::Other);
QCOMPARE(find.usages()[1].line, 4);
QCOMPARE(find.usages()[1].col, 16);
QCOMPARE(find.usages()[2].type, Usage::Type::Other);
QCOMPARE(find.usages()[2].line, 5);
QCOMPARE(find.usages()[2].col, 16);
}
void tst_FindUsages::memberFunctionFalsePositives_QTCREATORBUG2176()
{
const QByteArray src =
R"(
void otherFunction(int value){}
struct Struct{
static int foo(){return 1;}
int bar(){
int foo=Struct::foo();
otherFunction(foo);
}
};
)";
Document::Ptr doc = Document::create("memberFunctionFalsePositives");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 2);
Class *s = doc->globalSymbolAt(1)->asClass();
QVERIFY(s);
QCOMPARE(s->name()->identifier()->chars(), "Struct");
QCOMPARE(s->memberCount(), 2);
Symbol *memberFunctionFoo = s->memberAt(0);
QVERIFY(memberFunctionFoo);
QCOMPARE(memberFunctionFoo->name()->identifier()->chars(), "foo");
QVERIFY(memberFunctionFoo->asFunction());
Function* bar = s->memberAt(1)->asFunction();
QVERIFY(bar);
QCOMPARE(bar->name()->identifier()->chars(), "bar");
QCOMPARE(bar->memberCount(), 1);
Block* block = bar->memberAt(0)->asBlock();
QVERIFY(block);
QCOMPARE(block->memberCount(), 1);
Symbol *variableFoo = block->memberAt(0);
QVERIFY(variableFoo);
QCOMPARE(variableFoo->name()->identifier()->chars(), "foo");
QVERIFY(variableFoo->asDeclaration());
Snapshot snapshot;
snapshot.insert(doc);
FindUsages find(src, doc, snapshot);
find(memberFunctionFoo);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].type, Usage::Type::Declaration);
QCOMPARE(find.usages()[0].line, 3);
QCOMPARE(find.usages()[0].col, 15);
QCOMPARE(find.usages()[1].type, Usage::Type::Other);
QCOMPARE(find.usages()[1].line, 5);
QCOMPARE(find.usages()[1].col, 24);
find(variableFoo);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].type, Usage::Type::Initialization);
QCOMPARE(find.usages()[0].line, 5);
QCOMPARE(find.usages()[0].col, 12);
QCOMPARE(find.usages()[1].type, Usage::Type::Read);
QCOMPARE(find.usages()[1].line, 6);
QCOMPARE(find.usages()[1].col, 22);
}
void tst_FindUsages::resolveTemplateConstructor()
{
const QByteArray src =
R"(
struct MyStruct { int value; };
template <class T> struct Tmp {
T str;
};
template <class T> struct Tmp2 {
Tmp2(){}
T str;
};
template <class T> struct Tmp3 {
Tmp3(int i){}
T str;
};
int main() {
auto tmp = Tmp<MyStruct>();
auto tmp2 = Tmp2<MyStruct>();
auto tmp3 = Tmp3<MyStruct>(1);
tmp.str.value;
tmp2.str.value;
tmp3.str.value;
Tmp<MyStruct>().str.value;
Tmp2<MyStruct>().str.value;
Tmp3<MyStruct>(1).str.value;
}
)";
Document::Ptr doc = Document::create("resolveTemplateConstructor");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount() == 5);
Class *s = doc->globalSymbolAt(0)->asClass();
QVERIFY(s);
QCOMPARE(s->name()->identifier()->chars(), "MyStruct");
QCOMPARE(s->memberCount(), 1);
Declaration *sv = s->memberAt(0)->asDeclaration();
QVERIFY(sv);
QCOMPARE(sv->name()->identifier()->chars(), "value");
Snapshot snapshot;
snapshot.insert(doc);
FindUsages find(src, doc, snapshot);
find(sv);
QCOMPARE(find.usages().size(), 7);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
QCOMPARE(find.usages().at(2).type, Usage::Type::Read);
QCOMPARE(find.usages().at(3).type, Usage::Type::Read);
QCOMPARE(find.usages().at(4).type, Usage::Type::Read);
QCOMPARE(find.usages().at(5).type, Usage::Type::Read);
QCOMPARE(find.usages().at(6).type, Usage::Type::Read);
}
void tst_FindUsages::templateConstructorVsCallOperator()
{
const QByteArray src =
R"(
struct MyStruct { int value; };
template<class T> struct Tmp {
T str;
MyStruct operator()() { return MyStruct(); }
};
struct Simple {
MyStruct str;
MyStruct operator()() { return MyStruct(); }
};
int main()
{
Tmp<MyStruct>().str.value;
Tmp<MyStruct>()().value;
Tmp<MyStruct> t;
t().value;
Simple().str.value;
Simple()().value;
Simple s;
s().value;
}
)";
Document::Ptr doc = Document::create("resolveTemplateConstructor");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount() == 4);
Class *s = doc->globalSymbolAt(0)->asClass();
QVERIFY(s);
QCOMPARE(s->name()->identifier()->chars(), "MyStruct");
QCOMPARE(s->memberCount(), 1);
Declaration *sv = s->memberAt(0)->asDeclaration();
QVERIFY(sv);
QCOMPARE(sv->name()->identifier()->chars(), "value");
Snapshot snapshot;
snapshot.insert(doc);
FindUsages find(src, doc, snapshot);
find(sv);
QCOMPARE(find.usages().size(), 7);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
QCOMPARE(find.usages().at(2).type, Usage::Type::Read);
QCOMPARE(find.usages().at(3).type, Usage::Type::Read);
QCOMPARE(find.usages().at(4).type, Usage::Type::Read);
QCOMPARE(find.usages().at(5).type, Usage::Type::Read);
QCOMPARE(find.usages().at(6).type, Usage::Type::Read);
}
#if 0
@interface Clazz {} +(void)method:(int)arg; @end
@implementation Clazz +(void)method:(int)arg {
[Clazz method:arg];
}
@end
#endif
const QByteArray objcSource = "\n"
"@interface Clazz {} +(void)method:(int)arg; @end\n"
"@implementation Clazz +(void)method:(int)arg {\n"
" [Clazz method:arg];\n"
"}\n"
"@end\n";
void tst_FindUsages::objc_args()
{
Document::Ptr doc = Document::create("objc_args");
doc->setUtf8Source(objcSource);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 2);
Snapshot snapshot;
snapshot.insert(doc);
TranslationUnit *xUnit = doc->translationUnit();
QList<NameAST*>exprs = CollectNames(xUnit)("arg");
QCOMPARE(exprs.size(), 3);
ObjCClass *iface = doc->globalSymbolAt(0)->asObjCClass();
QVERIFY(iface);
QVERIFY(iface->isInterface());
QCOMPARE(iface->memberCount(), 1);
Declaration *methodIface = iface->memberAt(0)->asDeclaration();
QVERIFY(methodIface);
QCOMPARE(methodIface->identifier()->chars(), "method");
QVERIFY(methodIface->type()->isObjCMethodType());
ObjCClass *impl = doc->globalSymbolAt(1)->asObjCClass();
QVERIFY(impl);
QVERIFY(!impl->isInterface());
QCOMPARE(impl->memberCount(), 1);
ObjCMethod *methodImpl = impl->memberAt(0)->asObjCMethod();
QVERIFY(methodImpl);
QCOMPARE(methodImpl->identifier()->chars(), "method");
QCOMPARE(methodImpl->argumentCount(), 1);
Argument *arg = methodImpl->argumentAt(0)->asArgument();
QCOMPARE(arg->identifier()->chars(), "arg");
FindUsages findUsages(objcSource, doc, snapshot);
findUsages(arg);
QCOMPARE(findUsages.usages().size(), 2);
QCOMPARE(findUsages.references().size(), 2);
}
void tst_FindUsages::qproperty_1()
{
const QByteArray src = "\n"
"class Tst: public QObject {\n"
" Q_PROPERTY(int x READ x WRITE setX NOTIFY xChanged)\n"
"public:\n"
" int x() { return _x; }\n"
" void setX(int x) { if (_x != x) { _x = x; emit xChanged(x); } }\n"
"signals:\n"
" void xChanged(int);\n"
"private:\n"
" int _x;\n"
"};\n";
Document::Ptr doc = Document::create("qproperty_1");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 1);
Snapshot snapshot;
snapshot.insert(doc);
Class *tst = doc->globalSymbolAt(0)->asClass();
QVERIFY(tst);
QCOMPARE(tst->memberCount(), 5);
Function *setX_method = tst->memberAt(2)->asFunction();
QVERIFY(setX_method);
QCOMPARE(setX_method->identifier()->chars(), "setX");
QCOMPARE(setX_method->argumentCount(), 1);
FindUsages findUsages(src, doc, snapshot);
findUsages(setX_method);
QCOMPARE(findUsages.usages().size(), 2);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Declaration);
QCOMPARE(findUsages.references().size(), 2);
}
void tst_FindUsages::instantiateTemplateWithNestedClass()
{
const QByteArray src = "\n"
"struct Foo\n"
"{ int bar; };\n"
"template <typename T>\n"
"struct Template\n"
"{\n"
" struct Nested\n"
" {\n"
" T t;\n"
" }nested;\n"
"};\n"
"void f()\n"
"{\n"
" Template<Foo> templateFoo;\n"
" templateFoo.nested.t.bar;\n"
"}\n"
;
Document::Ptr doc = Document::create("simpleTemplate");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 3);
Snapshot snapshot;
snapshot.insert(doc);
Class *classFoo = doc->globalSymbolAt(0)->asClass();
QVERIFY(classFoo);
QCOMPARE(classFoo->memberCount(), 1);
Declaration *barDeclaration = classFoo->memberAt(0)->asDeclaration();
QVERIFY(barDeclaration);
QCOMPARE(barDeclaration->name()->identifier()->chars(), "bar");
FindUsages findUsages(src, doc, snapshot);
findUsages(barDeclaration);
QCOMPARE(findUsages.usages().size(), 2);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Read);
}
void tst_FindUsages::operatorAsteriskOfNestedClassOfTemplateClass_QTCREATORBUG9006()
{
const QByteArray src = "\n"
"struct Foo { int foo; };\n"
"\n"
"template<class T>\n"
"struct Outer\n"
"{\n"
" struct Nested\n"
" {\n"
" const T &operator*() { return t; }\n"
" T t;\n"
" };\n"
"};\n"
"\n"
"void bug()\n"
"{\n"
" Outer<Foo>::Nested nested;\n"
" (*nested).foo;\n"
"}\n"
;
Document::Ptr doc = Document::create("operatorAsteriskOfNestedClassOfTemplateClass_QTCREATORBUG9006");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 3);
Snapshot snapshot;
snapshot.insert(doc);
Class *classFoo = doc->globalSymbolAt(0)->asClass();
QVERIFY(classFoo);
QCOMPARE(classFoo->memberCount(), 1);
Declaration *fooDeclaration = classFoo->memberAt(0)->asDeclaration();
QVERIFY(fooDeclaration);
QCOMPARE(fooDeclaration->name()->identifier()->chars(), "foo");
FindUsages findUsages(src, doc, snapshot);
findUsages(fooDeclaration);
QCOMPARE(findUsages.usages().size(), 2);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Read);
}
void tst_FindUsages::anonymousClass_QTCREATORBUG8963()
{
const QByteArray src =
"typedef enum {\n"
" FIRST\n"
"} isNotInt;\n"
"typedef struct {\n"
" int isint;\n"
" int isNotInt;\n"
"} Struct;\n"
"void foo()\n"
"{\n"
" Struct s;\n"
" s.isint;\n"
" s.isNotInt;\n"
" FIRST;\n"
"}\n"
;
Document::Ptr doc = Document::create("anonymousClass_QTCREATORBUG8963");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 5);
Snapshot snapshot;
snapshot.insert(doc);
Class *structSymbol = doc->globalSymbolAt(2)->asClass();
QVERIFY(structSymbol);
QCOMPARE(structSymbol->memberCount(), 2);
Declaration *isNotIntDeclaration = structSymbol->memberAt(1)->asDeclaration();
QVERIFY(isNotIntDeclaration);
QCOMPARE(isNotIntDeclaration->name()->identifier()->chars(), "isNotInt");
FindUsages findUsages(src, doc, snapshot);
findUsages(isNotIntDeclaration);
QCOMPARE(findUsages.usages().size(), 2);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Read);
}
void tst_FindUsages::anonymousClass_QTCREATORBUG11859()
{
const QByteArray src =
"struct Foo {\n"
"};\n"
"typedef struct {\n"
" int Foo;\n"
"} Struct;\n"
"void foo()\n"
"{\n"
" Struct s;\n"
" s.Foo;\n"
"}\n"
;
Document::Ptr doc = Document::create("anonymousClass_QTCREATORBUG11859");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 4);
Snapshot snapshot;
snapshot.insert(doc);
Class *fooAsStruct = doc->globalSymbolAt(0)->asClass();
QVERIFY(fooAsStruct);
Class *structSymbol = doc->globalSymbolAt(1)->asClass();
QVERIFY(structSymbol);
QCOMPARE(structSymbol->memberCount(), 1);
Declaration *fooAsMemberOfAnonymousStruct = structSymbol->memberAt(0)->asDeclaration();
QVERIFY(fooAsMemberOfAnonymousStruct);
QCOMPARE(fooAsMemberOfAnonymousStruct->name()->identifier()->chars(), "Foo");
FindUsages findUsages(src, doc, snapshot);
findUsages(fooAsStruct);
QCOMPARE(findUsages.references().size(), 1);
QCOMPARE(findUsages.usages().size(), 1);
QCOMPARE(findUsages.usages().first().type, Usage::Type::Declaration);
findUsages(fooAsMemberOfAnonymousStruct);
QCOMPARE(findUsages.references().size(), 2);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Read);
}
void tst_FindUsages::using_insideGlobalNamespace()
{
const QByteArray src =
"namespace NS\n"
"{\n"
"struct Struct\n"
"{\n"
" int bar;\n"
"};\n"
"}\n"
"using NS::Struct;\n"
"void foo()\n"
"{\n"
" Struct s;\n"
"}\n"
;
Document::Ptr doc = Document::create("using_insideGlobalNamespace");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 3);
Snapshot snapshot;
snapshot.insert(doc);
Namespace *nsSymbol = doc->globalSymbolAt(0)->asNamespace();
QVERIFY(nsSymbol);
QCOMPARE(nsSymbol->memberCount(), 1);
Class *structSymbol = nsSymbol->memberAt(0)->asClass();
QVERIFY(structSymbol);
FindUsages findUsages(src, doc, snapshot);
findUsages(structSymbol);
QCOMPARE(findUsages.usages().size(), 3);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Other);
}
void tst_FindUsages::using_insideNamespace()
{
const QByteArray src =
"namespace NS\n"
"{\n"
"struct Struct\n"
"{\n"
" int bar;\n"
"};\n"
"}\n"
"namespace NS1\n"
"{\n"
"using NS::Struct;\n"
"void foo()\n"
"{\n"
" Struct s;\n"
"}\n"
"}\n"
;
Document::Ptr doc = Document::create("using_insideNamespace");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 2);
Snapshot snapshot;
snapshot.insert(doc);
Namespace *nsSymbol = doc->globalSymbolAt(0)->asNamespace();
QVERIFY(nsSymbol);
QCOMPARE(nsSymbol->memberCount(), 1);
Class *structSymbol = nsSymbol->memberAt(0)->asClass();
QVERIFY(structSymbol);
FindUsages findUsages(src, doc, snapshot);
findUsages(structSymbol);
QCOMPARE(findUsages.usages().size(), 3);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Other);
}
void tst_FindUsages::using_insideFunction()
{
const QByteArray src =
"namespace NS\n"
"{\n"
"struct Struct\n"
"{\n"
" int bar;\n"
"};\n"
"}\n"
"void foo()\n"
"{\n"
" using NS::Struct;\n"
" Struct s;\n"
"}\n"
;
Document::Ptr doc = Document::create("using_insideFunction");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 2);
Snapshot snapshot;
snapshot.insert(doc);
Namespace *nsSymbol = doc->globalSymbolAt(0)->asNamespace();
QVERIFY(nsSymbol);
QCOMPARE(nsSymbol->memberCount(), 1);
Class *structSymbol = nsSymbol->memberAt(0)->asClass();
QVERIFY(structSymbol);
FindUsages findUsages(src, doc, snapshot);
findUsages(structSymbol);
QCOMPARE(findUsages.usages().size(), 3);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Other);
}
void tst_FindUsages::operatorArrowOfNestedClassOfTemplateClass_QTCREATORBUG9005()
{
const QByteArray src = "\n"
"struct Foo { int foo; };\n"
"\n"
"template<class T>\n"
"struct Outer\n"
"{\n"
" struct Nested\n"
" {\n"
" T *operator->() { return 0; }\n"
" };\n"
"};\n"
"\n"
"void bug()\n"
"{\n"
" Outer<Foo>::Nested nested;\n"
" nested->foo;\n"
"}\n"
;
Document::Ptr doc = Document::create("operatorArrowOfNestedClassOfTemplateClass_QTCREATORBUG9005");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 3);
Snapshot snapshot;
snapshot.insert(doc);
Class *classFoo = doc->globalSymbolAt(0)->asClass();
QVERIFY(classFoo);
QCOMPARE(classFoo->memberCount(), 1);
Declaration *fooDeclaration = classFoo->memberAt(0)->asDeclaration();
QVERIFY(fooDeclaration);
QCOMPARE(fooDeclaration->name()->identifier()->chars(), "foo");
FindUsages findUsages(src, doc, snapshot);
findUsages(fooDeclaration);
QCOMPARE(findUsages.usages().size(), 2);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Read);
}
void tst_FindUsages::templateClassParameters()
{
const QByteArray src = "\n"
"template <class T>\n"
"struct TS\n"
"{\n"
" void set(T t) { T t1 = t; }\n"
" T get();\n"
" T t;\n"
"};\n"
;
Document::Ptr doc = Document::create("templateClassParameters");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 1);
Snapshot snapshot;
snapshot.insert(doc);
Template *templateClassTS = doc->globalSymbolAt(0)->asTemplate();
QVERIFY(templateClassTS);
QCOMPARE(templateClassTS->memberCount(), 2);
QCOMPARE(templateClassTS->templateParameterCount(), 1);
TypenameArgument *templArgument = templateClassTS->templateParameterAt(0)->asTypenameArgument();
QVERIFY(templArgument);
FindUsages findUsages(src, doc, snapshot);
findUsages(templArgument);
QCOMPARE(findUsages.usages().size(), 5);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(3).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(4).type, Usage::Type::Other);
}
void tst_FindUsages::templateClass_className()
{
const QByteArray src = "\n"
"template <class T>\n"
"struct TS\n"
"{\n"
" TS();\n"
" ~TS();\n"
"};\n"
"template <class T>\n"
"TS<T>::TS()\n"
"{\n"
"}\n"
"template <class T>\n"
"TS<T>::~TS()\n"
"{\n"
"}\n"
;
Document::Ptr doc = Document::create("templateClass_className");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 3);
Snapshot snapshot;
snapshot.insert(doc);
Template *templateClassTS = doc->globalSymbolAt(0)->asTemplate();
QVERIFY(templateClassTS);
Class *classTS = templateClassTS->memberAt(1)->asClass();
QVERIFY(classTS);
QCOMPARE(classTS->memberCount(), 2);
FindUsages findUsages(src, doc, snapshot);
findUsages(classTS);
QCOMPARE(findUsages.usages().size(), 7);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(3).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(4).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(5).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(6).type, Usage::Type::Other);
}
void tst_FindUsages::templateFunctionParameters()
{
const QByteArray src = "\n"
"template<class T>\n"
"T foo(T t)\n"
"{\n"
" typename T;\n"
"}\n"
;
Document::Ptr doc = Document::create("templateFunctionParameters");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 1);
Snapshot snapshot;
snapshot.insert(doc);
Template *templateFunctionTS = doc->globalSymbolAt(0)->asTemplate();
QVERIFY(templateFunctionTS);
QCOMPARE(templateFunctionTS->memberCount(), 2);
QCOMPARE(templateFunctionTS->templateParameterCount(), 1);
TypenameArgument *templArgument = templateFunctionTS->templateParameterAt(0)->asTypenameArgument();
QVERIFY(templArgument);
FindUsages findUsages(src, doc, snapshot);
findUsages(templArgument);
QCOMPARE(findUsages.usages().size(), 4);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(3).type, Usage::Type::Other);
}
void tst_FindUsages::templatedFunction_QTCREATORBUG9749()
{
const QByteArray src = "\n"
"template <class IntType> char *reformatInteger(IntType value, int format) {}\n"
"void func(int code, int format) {\n"
" reformatInteger(code, format);"
"}\n"
;
Document::Ptr doc = Document::create("templatedFunction_QTCREATORBUG9749");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 2);
Snapshot snapshot;
snapshot.insert(doc);
Template *funcTempl = doc->globalSymbolAt(0)->asTemplate();
QVERIFY(funcTempl);
QCOMPARE(funcTempl->memberCount(), 2);
Function *func = funcTempl->memberAt(1)->asFunction();
FindUsages findUsages(src, doc, snapshot);
findUsages(func);
QCOMPARE(findUsages.usages().size(), 2);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
}
void tst_FindUsages::usingInDifferentNamespace_QTCREATORBUG7978()
{
const QByteArray src = "\n"
"struct S {};\n"
"namespace std\n"
"{\n"
" template <typename T> struct shared_ptr{};\n"
"}\n"
"namespace NS\n"
"{\n"
" using std::shared_ptr;\n"
"}\n"
"void fun()\n"
"{\n"
" NS::shared_ptr<S> p;\n"
"}\n"
;
Document::Ptr doc = Document::create("usingInDifferentNamespace_QTCREATORBUG7978");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 4);
Snapshot snapshot;
snapshot.insert(doc);
Namespace *ns = doc->globalSymbolAt(1)->asNamespace();
QVERIFY(ns);
QCOMPARE(ns->memberCount(), 1);
Template *templateClass = ns->memberAt(0)->asTemplate();
FindUsages findUsages(src, doc, snapshot);
findUsages(templateClass);
QCOMPARE(findUsages.usages().size(), 3);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Other);
QCOMPARE(findUsages.usages().at(2).type, Usage::Type::Other);
}
void tst_FindUsages::unicodeIdentifier()
{
const QByteArray src = "\n"
"int var" TEST_UNICODE_IDENTIFIER ";\n"
"void f() { var" TEST_UNICODE_IDENTIFIER " = 1; }\n";
;
Document::Ptr doc = Document::create("u");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 2);
Snapshot snapshot;
snapshot.insert(doc);
Declaration *declaration = doc->globalSymbolAt(0)->asDeclaration();
QVERIFY(declaration);
FindUsages findUsages(src, doc, snapshot);
findUsages(declaration);
const QList<Usage> usages = findUsages.usages();
QCOMPARE(usages.size(), 2);
QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Write);
QCOMPARE(usages.at(0).len, 7);
QCOMPARE(usages.at(1).len, 7);
}
void tst_FindUsages::inAlignas()
{
const QByteArray src = "\n"
"struct One {};\n"
"struct alignas(One) Two {};\n"
;
Document::Ptr doc = Document::create("inAlignas");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 2);
Snapshot snapshot;
snapshot.insert(doc);
Class *c = doc->globalSymbolAt(0)->asClass();
QVERIFY(c);
QCOMPARE(c->name()->identifier()->chars(), "One");
FindUsages find(src, doc, snapshot);
find(c);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].type, Usage::Type::Declaration);
QCOMPARE(find.usages()[0].line, 1);
QCOMPARE(find.usages()[0].col, 7);
QCOMPARE(find.usages()[1].type, Usage::Type::Other);
QCOMPARE(find.usages()[1].line, 2);
QCOMPARE(find.usages()[1].col, 15);
}
void tst_FindUsages::memberAccessAsTemplate()
{
const QByteArray src = "\n"
"struct Foo {};\n"
"struct Bar {\n"
" template <typename T>\n"
" T *templateFunc() { return 0; }\n"
"};\n"
"struct Test {\n"
" Bar member;\n"
" void testFunc();\n"
"};\n"
"void Test::testFunc() {\n"
" member.templateFunc<Foo>();\n"
"}\n";
Document::Ptr doc = Document::create("memberAccessAsTemplate");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 4);
Snapshot snapshot;
snapshot.insert(doc);
{ // Test "Foo"
Class *c = doc->globalSymbolAt(0)->asClass();
QVERIFY(c);
QCOMPARE(c->name()->identifier()->chars(), "Foo");
FindUsages find(src, doc, snapshot);
find(c);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].type, Usage::Type::Declaration);
QCOMPARE(find.usages()[0].line, 1);
QCOMPARE(find.usages()[0].col, 7);
QCOMPARE(find.usages()[1].type, Usage::Type::Other);
QCOMPARE(find.usages()[1].line, 11);
QCOMPARE(find.usages()[1].col, 24);
}
{ // Test "templateFunc"
Class *c = doc->globalSymbolAt(1)->asClass();
QVERIFY(c);
QCOMPARE(c->name()->identifier()->chars(), "Bar");
QCOMPARE(c->memberCount(), 1);
Template *f = c->memberAt(0)->asTemplate();
QVERIFY(f);
QCOMPARE(f->name()->identifier()->chars(), "templateFunc");
FindUsages find(src, doc, snapshot);
find(f);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].type, Usage::Type::Declaration);
QCOMPARE(find.usages()[0].line, 4);
QCOMPARE(find.usages()[0].col, 7);
QCOMPARE(find.usages()[1].type, Usage::Type::Other);
QCOMPARE(find.usages()[1].line, 11);
QCOMPARE(find.usages()[1].col, 11);
}
}
void tst_FindUsages::variadicFunctionTemplate()
{
const QByteArray src = "struct S{int value;};\n"
"template<class ... Types> S foo(Types & ... args){return S();}\n"
"int main(){\n"
" foo().value;\n"
" foo(1).value;\n"
" foo(1,2).value;\n"
"}";
Document::Ptr doc = Document::create("variadicFunctionTemplate");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount()>=1);
Snapshot snapshot;
snapshot.insert(doc);
{ // Test "S::value"
Class *c = doc->globalSymbolAt(0)->asClass();
QVERIFY(c);
QCOMPARE(c->name()->identifier()->chars(), "S");
QCOMPARE(c->memberCount(), 1);
Declaration *v = c->memberAt(0)->asDeclaration();
QVERIFY(v);
QCOMPARE(v->name()->identifier()->chars(), "value");
FindUsages find(src, doc, snapshot);
find(v);
QCOMPARE(find.usages().size(), 4);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
QCOMPARE(find.usages().at(2).type, Usage::Type::Read);
QCOMPARE(find.usages().at(3).type, Usage::Type::Read);
}
}
void tst_FindUsages::typeTemplateParameterWithDefault()
{
const QByteArray src = "struct X{int value;};\n"
"struct S{int value;};\n"
"template<class T = S> T foo(){return T();}\n"
"int main(){\n"
" foo<X>().value;\n"
" foo<S>().value;\n"
" foo().value;\n" // this is S.value
"}";
Document::Ptr doc = Document::create("typeTemplateParameterWithDefault");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount()>=2);
Snapshot snapshot;
snapshot.insert(doc);
{ // Test "S::value"
Class *x = doc->globalSymbolAt(0)->asClass();
QVERIFY(x);
QCOMPARE(x->name()->identifier()->chars(), "X");
QCOMPARE(x->memberCount(), 1);
Class *s = doc->globalSymbolAt(1)->asClass();
QVERIFY(s);
QCOMPARE(s->name()->identifier()->chars(), "S");
QCOMPARE(s->memberCount(), 1);
Declaration *xv = x->memberAt(0)->asDeclaration();
QVERIFY(xv);
QCOMPARE(xv->name()->identifier()->chars(), "value");
Declaration *sv = s->memberAt(0)->asDeclaration();
QVERIFY(sv);
QCOMPARE(sv->name()->identifier()->chars(), "value");
FindUsages find(src, doc, snapshot);
find(xv);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
find(sv);
QCOMPARE(find.usages().size(), 3);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
QCOMPARE(find.usages().at(2).type, Usage::Type::Read);
}
}
void tst_FindUsages::resolveOrder_for_templateFunction_vs_function()
{
const QByteArray src = "struct X{int value;};\n"
"struct S{int value;};\n"
"X foo(){return X();}\n"
"template<class T = S> T foo(){return T();}\n"
"int main(){\n"
" foo().value;\n" // this is X.value
"}";
Document::Ptr doc = Document::create("resolveOrder_for_templateFunction_vs_function");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount()>=1);
Snapshot snapshot;
snapshot.insert(doc);
{ // Test "S::value"
Class *x = doc->globalSymbolAt(0)->asClass();
QVERIFY(x);
QCOMPARE(x->name()->identifier()->chars(), "X");
QCOMPARE(x->memberCount(), 1);
Declaration *xv = x->memberAt(0)->asDeclaration();
QVERIFY(xv);
QCOMPARE(xv->name()->identifier()->chars(), "value");
FindUsages find(src, doc, snapshot);
find(xv);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
}
}
void tst_FindUsages::templateArrowOperator_with_defaultType()
{
const QByteArray src = "struct S{int value;};\n"
"struct C{\n"
" S* s;\n"
" template<class T = S> \n"
" T* operator->(){return &s;}\n"
"};\n"
"int main(){\n"
" C().operator -> ()->value;\n"
" C()->value;\n"
"}\n";
Document::Ptr doc = Document::create("templateArrowOperator_with_defaultType");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount()>=1);
Snapshot snapshot;
snapshot.insert(doc);
{ // Test "S::value"
Class *s = doc->globalSymbolAt(0)->asClass();
QVERIFY(s);
QCOMPARE(s->name()->identifier()->chars(), "S");
QCOMPARE(s->memberCount(), 1);
Declaration *sv = s->memberAt(0)->asDeclaration();
QVERIFY(sv);
QCOMPARE(sv->name()->identifier()->chars(), "value");
FindUsages find(src, doc, snapshot);
find(sv);
QCOMPARE(find.usages().size(), 3);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
QCOMPARE(find.usages().at(2).type, Usage::Type::Read);
}
}
void tst_FindUsages::templateSpecialization_with_IntArgument()
{
const QByteArray src = "\n"
"struct S0{ int value = 0; };\n"
"struct S1{ int value = 1; };\n"
"struct S2{ int value = 2; };\n"
"template<int N> struct S { S0 s; };\n"
"template<> struct S<1> { S1 s; };\n"
"template<> struct S<2> { S2 s; };\n"
"int main()\n"
"{\n"
" S<0> s0;\n"
" S<1> s1;\n"
" S<2> s2;\n"
" s0.s.value;\n"
" s1.s.value;\n"
" s2.s.value = s2.s.value;\n"
"}\n";
Document::Ptr doc = Document::create("templateSpecialization_with_IntArgument");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount()>=3);
Snapshot snapshot;
snapshot.insert(doc);
{
Class *s[3] = {
doc->globalSymbolAt(0)->asClass(),
doc->globalSymbolAt(1)->asClass(),
doc->globalSymbolAt(2)->asClass(),
};
QVERIFY(s[0]);
QVERIFY(s[1]);
QVERIFY(s[2]);
QCOMPARE(s[0]->name()->identifier()->chars(), "S0");
QCOMPARE(s[1]->name()->identifier()->chars(), "S1");
QCOMPARE(s[2]->name()->identifier()->chars(), "S2");
QCOMPARE(s[0]->memberCount(), 1);
QCOMPARE(s[1]->memberCount(), 1);
QCOMPARE(s[2]->memberCount(), 1);
Declaration *sv[3] = {
s[0]->memberAt(0)->asDeclaration(),
s[1]->memberAt(0)->asDeclaration(),
s[2]->memberAt(0)->asDeclaration(),
};
QVERIFY(sv[0]);
QVERIFY(sv[1]);
QVERIFY(sv[2]);
QCOMPARE(sv[0]->name()->identifier()->chars(), "value");
QCOMPARE(sv[1]->name()->identifier()->chars(), "value");
QCOMPARE(sv[2]->name()->identifier()->chars(), "value");
FindUsages find(src, doc, snapshot);
find(sv[0]);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].line, 1);
QCOMPARE(find.usages()[0].col, 15);
QCOMPARE(find.usages()[1].line, 12);
QCOMPARE(find.usages()[1].col, 9);
find(sv[1]);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].type, Usage::Type::Initialization);
QCOMPARE(find.usages()[0].line, 2);
QCOMPARE(find.usages()[0].col, 15);
QCOMPARE(find.usages()[1].type, Usage::Type::Read);
QCOMPARE(find.usages()[1].line, 13);
QCOMPARE(find.usages()[1].col, 9);
find(sv[2]);
QCOMPARE(find.usages().size(), 3);
QCOMPARE(find.usages()[0].type, Usage::Type::Initialization);
QCOMPARE(find.usages()[0].line, 3);
QCOMPARE(find.usages()[0].col, 15);
QCOMPARE(find.usages()[1].type, Usage::Type::Write);
QCOMPARE(find.usages()[1].line, 14);
QCOMPARE(find.usages()[1].col, 9);
QCOMPARE(find.usages()[2].type, Usage::Type::Read);
QCOMPARE(find.usages()[2].line, 14);
QCOMPARE(find.usages()[2].col, 22);
}
}
void tst_FindUsages::templateSpecialization_with_BoolArgument()
{
const QByteArray src = "\n"
"struct S0{ int value = 0; };\n"
"struct S1{ int value = 1; };\n"
"template<bool B> struct S { S0 s; };\n"
"template<> struct S<true> { S1 s; };\n"
"int main()\n"
"{\n"
" S<false> s0;\n"
" S<true> s1;\n"
" s0.s.value;\n"
" s1.s.value;\n"
"}\n";
Document::Ptr doc = Document::create("templateSpecialization_with_BoolArgument");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount()>=3);
Snapshot snapshot;
snapshot.insert(doc);
{
Class *s[2] = {
doc->globalSymbolAt(0)->asClass(),
doc->globalSymbolAt(1)->asClass(),
};
QVERIFY(s[0]);
QVERIFY(s[1]);
QCOMPARE(s[0]->name()->identifier()->chars(), "S0");
QCOMPARE(s[1]->name()->identifier()->chars(), "S1");
QCOMPARE(s[0]->memberCount(), 1);
QCOMPARE(s[1]->memberCount(), 1);
Declaration *sv[2] = {
s[0]->memberAt(0)->asDeclaration(),
s[1]->memberAt(0)->asDeclaration(),
};
QVERIFY(sv[0]);
QVERIFY(sv[1]);
QCOMPARE(sv[0]->name()->identifier()->chars(), "value");
QCOMPARE(sv[1]->name()->identifier()->chars(), "value");
FindUsages find(src, doc, snapshot);
find(sv[0]);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].type, Usage::Type::Initialization);
QCOMPARE(find.usages()[0].line, 1);
QCOMPARE(find.usages()[0].col, 15);
QCOMPARE(find.usages()[1].type, Usage::Type::Read);
QCOMPARE(find.usages()[1].line, 9);
QCOMPARE(find.usages()[1].col, 9);
find(sv[1]);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].type, Usage::Type::Initialization);
QCOMPARE(find.usages()[0].line, 2);
QCOMPARE(find.usages()[0].col, 15);
QCOMPARE(find.usages()[1].type, Usage::Type::Read);
QCOMPARE(find.usages()[1].line, 10);
QCOMPARE(find.usages()[1].col, 9);
}
}
void tst_FindUsages::templatePartialSpecialization()
{
const QByteArray src = "\n"
"struct S0{ int value = 0; };\n"
"struct S1{ int value = 1; };\n"
"template<class T, class U> struct S { S0 ss; };\n"
"template<class U> struct S<float, U> { S1 ss; };\n"
"int main()\n"
"{\n"
" S<int, int> s0;\n"
" S<float, int> s1;\n"
" s0.ss.value;\n"
" s1.ss.value;\n"
"}\n";
Document::Ptr doc = Document::create("templatePartialSpecialization");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount()>=3);
Snapshot snapshot;
snapshot.insert(doc);
{
Class *s[2] = {
doc->globalSymbolAt(0)->asClass(),
doc->globalSymbolAt(1)->asClass(),
};
QVERIFY(s[0]);
QVERIFY(s[1]);
QCOMPARE(s[0]->name()->identifier()->chars(), "S0");
QCOMPARE(s[1]->name()->identifier()->chars(), "S1");
QCOMPARE(s[0]->memberCount(), 1);
QCOMPARE(s[1]->memberCount(), 1);
Declaration *sv[2] = {
s[0]->memberAt(0)->asDeclaration(),
s[1]->memberAt(0)->asDeclaration(),
};
QVERIFY(sv[0]);
QVERIFY(sv[1]);
QCOMPARE(sv[0]->name()->identifier()->chars(), "value");
QCOMPARE(sv[1]->name()->identifier()->chars(), "value");
FindUsages find(src, doc, snapshot);
find(sv[0]);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].type, Usage::Type::Initialization);
QCOMPARE(find.usages()[0].line, 1);
QCOMPARE(find.usages()[0].col, 15);
QCOMPARE(find.usages()[1].type, Usage::Type::Read);
QCOMPARE(find.usages()[1].line, 9);
QCOMPARE(find.usages()[1].col, 10);
find(sv[1]);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages()[0].type, Usage::Type::Initialization);
QCOMPARE(find.usages()[0].line, 2);
QCOMPARE(find.usages()[0].col, 15);
QCOMPARE(find.usages()[1].type, Usage::Type::Read);
QCOMPARE(find.usages()[1].line, 10);
QCOMPARE(find.usages()[1].col, 10);
}
}
void tst_FindUsages::templatePartialSpecialization_2()
{
const QByteArray src =
R"(
struct S0{int value=0;};
struct S1{int value=1;};
struct S2{int value=2;};
template<class T1, class T2> struct S{T1 ss;};
template<class U> struct S<int, U>{ U ss; };
template<class V> struct S<V*, int>{ V *ss; };
int main()
{
S<S0, float> s0;
s0.ss.value;
S<int, S1> s1;
s1.ss.value;
S<S2*, int> s2;
s2.ss->value;
}
)";
Document::Ptr doc = Document::create("templatePartialSpecialization_2");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount()>=3);
Snapshot snapshot;
snapshot.insert(doc);
FindUsages find(src, doc, snapshot);
Class *s[3];
Declaration *sv[3];
for (int i = 0; i < 3; i++) {
s[i] = doc->globalSymbolAt(i)->asClass();
QVERIFY(s[i]);
QCOMPARE(s[i]->memberCount(), 1);
sv[i] = s[i]->memberAt(0)->asDeclaration();
QVERIFY(sv[i]);
QCOMPARE(sv[i]->name()->identifier()->chars(), "value");
}
QCOMPARE(s[0]->name()->identifier()->chars(), "S0");
QCOMPARE(s[1]->name()->identifier()->chars(), "S1");
QCOMPARE(s[2]->name()->identifier()->chars(), "S2");
find(sv[0]);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages().at(0).type, Usage::Type::Initialization);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
find(sv[1]);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages().at(0).type, Usage::Type::Initialization);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
find(sv[2]);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages().at(0).type, Usage::Type::Initialization);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
}
void tst_FindUsages::template_SFINAE_1()
{
const QByteArray src =
R"(
struct S{int value=1;};
template<class, class> struct is_same {};
template<class T> struct is_same<T, T> {using type = int;};
template<class T = S, typename is_same<T, S>::type = 0> T* foo(){return new T();}
int main(){
foo()->value;
}
)";
Document::Ptr doc = Document::create("template_SFINAE_1");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount()>=1);
Snapshot snapshot;
snapshot.insert(doc);
Class *s = doc->globalSymbolAt(0)->asClass();
QVERIFY(s);
QCOMPARE(s->name()->identifier()->chars(), "S");
QCOMPARE(s->memberCount(), 1);
Declaration *sv = s->memberAt(0)->asDeclaration();
QVERIFY(sv);
QCOMPARE(sv->name()->identifier()->chars(), "value");
FindUsages find(src, doc, snapshot);
find(sv);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages().at(0).type, Usage::Type::Initialization);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
}
void tst_FindUsages::variableTemplateInExpression()
{
const QByteArray src =
R"(
struct S{int value;};
template<class T> constexpr int foo = sizeof(T);
template<class T1, class T2>
struct pair{
pair() noexcept(foo<T1> + foo<T2>){}
T1 first;
T2 second;
};
int main(){
pair<int, S> pair;
pair.second.value;
}
)";
Document::Ptr doc = Document::create("variableTemplateInExpression");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount()>=1);
Snapshot snapshot;
snapshot.insert(doc);
Class *s = doc->globalSymbolAt(0)->asClass();
QVERIFY(s);
QCOMPARE(s->name()->identifier()->chars(), "S");
QCOMPARE(s->memberCount(), 1);
Declaration *sv = s->memberAt(0)->asDeclaration();
QVERIFY(sv);
QCOMPARE(sv->name()->identifier()->chars(), "value");
FindUsages find(src, doc, snapshot);
find(sv);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
}
void tst_FindUsages::variadicMacros()
{
const QByteArray src =
R"(
struct MyStruct { int value; };
#define FOO( ... ) int foo()
FOO(1) {
MyStruct s;
s.value;
}
int main(){}
)";
Document::Ptr doc = Document::create("variadicMacros");
doc->setUtf8Source(src);
doc->parse();
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QVERIFY(doc->globalSymbolCount() >= 1);
Snapshot snapshot;
snapshot.insert(doc);
Class *s = doc->globalSymbolAt(0)->asClass();
QVERIFY(s);
QCOMPARE(s->name()->identifier()->chars(), "MyStruct");
QCOMPARE(s->memberCount(), 1);
Declaration *sv = s->memberAt(0)->asDeclaration();
QVERIFY(sv);
QCOMPARE(sv->name()->identifier()->chars(), "value");
FindUsages find(src, doc, snapshot);
find(sv);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::Read);
}
void tst_FindUsages::writableRefs()
{
const QByteArray src = R"(
struct S {
S() : value2(value) {}
static int value;
int value2;
static void *p;
static const void *p2;
struct Nested {
int constFunc() const;
void constFunc(int) const;
void nonConstFunc();
} n;
Nested constFunc() const;
void nonConstFunc();
static void staticFunc1() {}
static void staticFunc2();
};
void func1(int &);
void func2(const int &);
void func3(int *);
void func4(const int *);
void func5(int);
int main()
{
S s;
auto *p = &s.value;
int **pp;
p = &s.value;
*pp = &s.value;
//p = &s::value; FIXME: This one is not found at all...
s.p = &s.value;
// s::p = &s::value; FIXME: Same here.
(&s)->p = &((new S)->value);
const int *p2 = &s.value;
s.p2 = &s.value;
int * const p3 = &s.value;
int &r = s.value;
const int &cr = s.value;
func1(s.value);
func2(s.value);
func3(&s.value);
func4(&s.value);
func5(s.value);
*p = 5;
func1(*p);
func2(*p);
func3(p);
func4(p);
func5(p);
int &r2 = *p;
const int &cr2 = *p;
s = S();
auto * const ps = &s;
const auto *ps2 = &s;
auto &pr = s;
const auto pr2 = &s;
s.constFunc().nonConstFunc();
s.nonConstFunc();
(&s)->nonConstFunc();
s.n.constFunc();
s.n.nonConstFunc();
s.n.constFunc(s.value);
delete s.p;
switch (S::value) {
case S::value: break;
}
switch (S::value = 5) {
default: break;
}
if (S::value) {}
if (S::value = 0) {}
++S::value;
S::value--;
s.staticFunc1();
s.staticFunc2();
}
)";
const Document::Ptr doc = Document::create("writableRefs");
doc->setUtf8Source(src);
doc->check();
QVERIFY(doc->diagnosticMessages().isEmpty());
QCOMPARE(doc->globalSymbolCount(), 7);
Snapshot snapshot;
snapshot.insert(doc);
Class * const structS = doc->globalSymbolAt(0)->asClass();
QVERIFY(structS);
QCOMPARE(structS->name()->identifier()->chars(), "S");
QCOMPARE(structS->memberCount(), 11);
Declaration * const sv = structS->memberAt(1)->asDeclaration();
QVERIFY(sv);
QCOMPARE(sv->name()->identifier()->chars(), "value");
// Access to struct member
FindUsages find(src, doc, snapshot);
find(sv);
QCOMPARE(find.usages().size(), 25);
QCOMPARE(find.usages().at(0).type, Usage::Type::Read);
QCOMPARE(find.usages().at(1).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(2).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(3).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(4).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(5).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(6).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(7).type, Usage::Type::Read);
QCOMPARE(find.usages().at(8).type, Usage::Type::Read);
QCOMPARE(find.usages().at(9).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(10).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(11).type, Usage::Type::Read);
QCOMPARE(find.usages().at(12).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(13).type, Usage::Type::Read);
QCOMPARE(find.usages().at(14).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(15).type, Usage::Type::Read);
QCOMPARE(find.usages().at(16).type, Usage::Type::Read);
QCOMPARE(find.usages().at(17).type, Usage::Type::Read);
QCOMPARE(find.usages().at(18).type, Usage::Type::Read);
QCOMPARE(find.usages().at(19).type, Usage::Type::Read);
QCOMPARE(find.usages().at(20).type, Usage::Type::Write);
QCOMPARE(find.usages().at(21).type, Usage::Type::Read);
QCOMPARE(find.usages().at(22).type, Usage::Type::Write);
QCOMPARE(find.usages().at(23).type, Usage::Type::Write);
QCOMPARE(find.usages().at(24).type, Usage::Type::Write);
Declaration * const sv2 = structS->memberAt(2)->asDeclaration();
QVERIFY(sv2);
QCOMPARE(sv2->name()->identifier()->chars(), "value2");
// Member initialization in constructor
find(sv2);
QCOMPARE(find.usages().size(), 2);
QCOMPARE(find.usages().at(0).type, Usage::Type::Write);
QCOMPARE(find.usages().at(1).type, Usage::Type::Declaration);
Function * const main = doc->globalSymbolAt(6)->asFunction();
QVERIFY(main);
QCOMPARE(main->memberCount(), 1);
Block * const block = main->memberAt(0)->asBlock();
QVERIFY(block);
QCOMPARE(block->memberCount(), 17);
// Access to pointer
Declaration * const p = block->memberAt(1)->asDeclaration();
QVERIFY(p);
QCOMPARE(p->name()->identifier()->chars(), "p");
find(p);
QCOMPARE(find.usages().size(), 10);
QCOMPARE(find.usages().at(0).type, Usage::Type::Initialization);
QCOMPARE(find.usages().at(1).type, Usage::Type::Write);
QCOMPARE(find.usages().at(2).type, Usage::Type::Write);
QCOMPARE(find.usages().at(3).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(4).type, Usage::Type::Read);
QCOMPARE(find.usages().at(5).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(6).type, Usage::Type::Read);
QCOMPARE(find.usages().at(7).type, Usage::Type::Read);
QCOMPARE(find.usages().at(8).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(9).type, Usage::Type::Read);
// Access to struct variable via its members
Declaration * const varS = block->memberAt(0)->asDeclaration();
QVERIFY(varS);
QCOMPARE(varS->name()->identifier()->chars(), "s");
find(varS);
QCOMPARE(find.usages().size(), 33);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(2).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(3).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(4).type, Usage::Type::Write);
QCOMPARE(find.usages().at(5).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(6).type, Usage::Type::Write);
QCOMPARE(find.usages().at(7).type, Usage::Type::Read);
QCOMPARE(find.usages().at(8).type, Usage::Type::Write);
QCOMPARE(find.usages().at(9).type, Usage::Type::Read);
QCOMPARE(find.usages().at(10).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(11).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(12).type, Usage::Type::Read);
QCOMPARE(find.usages().at(13).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(14).type, Usage::Type::Read);
QCOMPARE(find.usages().at(15).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(16).type, Usage::Type::Read);
QCOMPARE(find.usages().at(17).type, Usage::Type::Read);
// Direct access to struct variable
QCOMPARE(find.usages().at(18).type, Usage::Type::Write);
QCOMPARE(find.usages().at(19).type, Usage::Type::WritableRef);
QEXPECT_FAIL(nullptr, "parser does not record const qualifier for auto types", Continue);
QCOMPARE(find.usages().at(20).type, Usage::Type::Read);
QEXPECT_FAIL(nullptr, "parser does not record reference qualifier for auto types", Continue);
QCOMPARE(find.usages().at(21).type, Usage::Type::WritableRef);
QEXPECT_FAIL(nullptr, "parser does not record const qualifier for auto types", Continue);
QCOMPARE(find.usages().at(22).type, Usage::Type::Read);
// Member function calls.
QCOMPARE(find.usages().at(23).type, Usage::Type::Read);
QCOMPARE(find.usages().at(24).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(25).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(26).type, Usage::Type::Read);
QCOMPARE(find.usages().at(27).type, Usage::Type::WritableRef);
QCOMPARE(find.usages().at(28).type, Usage::Type::Read);
QCOMPARE(find.usages().at(29).type, Usage::Type::Read);
QEXPECT_FAIL(nullptr, "parser does not expose static specifier", Continue);
QCOMPARE(find.usages().at(31).type, Usage::Type::Other);
QEXPECT_FAIL(nullptr, "parser does not expose static specifier", Continue);
QCOMPARE(find.usages().at(32).type, Usage::Type::Other);
// Usages of struct type
find(structS);
QCOMPARE(find.usages().size(), 12);
QCOMPARE(find.usages().at(0).type, Usage::Type::Declaration);
QCOMPARE(find.usages().at(1).type, Usage::Type::Other);
QCOMPARE(find.usages().at(2).type, Usage::Type::Other);
QCOMPARE(find.usages().at(3).type, Usage::Type::Other);
QCOMPARE(find.usages().at(4).type, Usage::Type::Other);
// These are conceptually questionable, as S is a type and thus we cannot "read from"
// or "write to" it. But it possibly matches the intuitive user expectation.
QCOMPARE(find.usages().at(5).type, Usage::Type::Read);
QCOMPARE(find.usages().at(6).type, Usage::Type::Read);
QCOMPARE(find.usages().at(7).type, Usage::Type::Write);
QCOMPARE(find.usages().at(8).type, Usage::Type::Read);
QCOMPARE(find.usages().at(9).type, Usage::Type::Write);
QCOMPARE(find.usages().at(10).type, Usage::Type::Write);
QCOMPARE(find.usages().at(11).type, Usage::Type::Write);
}
QTEST_APPLESS_MAIN(tst_FindUsages)
#include "tst_findusages.moc"
View Git Blame Copy Permalink