forked from OSchip/llvm-project
241 lines
8.8 KiB
C++
241 lines
8.8 KiB
C++
// RUN: %check_clang_tidy %s readability-qualified-auto %t
|
|
|
|
namespace typedefs {
|
|
typedef int *MyPtr;
|
|
typedef int &MyRef;
|
|
typedef const int *CMyPtr;
|
|
typedef const int &CMyRef;
|
|
|
|
MyPtr getPtr();
|
|
MyRef getRef();
|
|
CMyPtr getCPtr();
|
|
CMyRef getCRef();
|
|
|
|
void foo() {
|
|
auto TdNakedPtr = getPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto TdNakedPtr' can be declared as 'auto *TdNakedPtr'
|
|
// CHECK-FIXES: {{^}} auto *TdNakedPtr = getPtr();
|
|
auto &TdNakedRef = getRef();
|
|
auto TdNakedRefDeref = getRef();
|
|
auto TdNakedCPtr = getCPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto TdNakedCPtr' can be declared as 'const auto *TdNakedCPtr'
|
|
// CHECK-FIXES: {{^}} const auto *TdNakedCPtr = getCPtr();
|
|
auto &TdNakedCRef = getCRef();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto &TdNakedCRef' can be declared as 'const auto &TdNakedCRef'
|
|
// CHECK-FIXES: {{^}} const auto &TdNakedCRef = getCRef();
|
|
auto TdNakedCRefDeref = getCRef();
|
|
}
|
|
|
|
}; // namespace typedefs
|
|
|
|
namespace usings {
|
|
using MyPtr = int *;
|
|
using MyRef = int &;
|
|
using CMyPtr = const int *;
|
|
using CMyRef = const int &;
|
|
|
|
MyPtr getPtr();
|
|
MyRef getRef();
|
|
CMyPtr getCPtr();
|
|
CMyRef getCRef();
|
|
|
|
void foo() {
|
|
auto UNakedPtr = getPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto UNakedPtr' can be declared as 'auto *UNakedPtr'
|
|
// CHECK-FIXES: {{^}} auto *UNakedPtr = getPtr();
|
|
auto &UNakedRef = getRef();
|
|
auto UNakedRefDeref = getRef();
|
|
auto UNakedCPtr = getCPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto UNakedCPtr' can be declared as 'const auto *UNakedCPtr'
|
|
// CHECK-FIXES: {{^}} const auto *UNakedCPtr = getCPtr();
|
|
auto &UNakedCRef = getCRef();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto &UNakedCRef' can be declared as 'const auto &UNakedCRef'
|
|
// CHECK-FIXES: {{^}} const auto &UNakedCRef = getCRef();
|
|
auto UNakedCRefDeref = getCRef();
|
|
}
|
|
|
|
}; // namespace usings
|
|
|
|
int getInt();
|
|
int *getIntPtr();
|
|
const int *getCIntPtr();
|
|
|
|
void foo() {
|
|
// make sure check disregards named types
|
|
int TypedInt = getInt();
|
|
int *TypedPtr = getIntPtr();
|
|
const int *TypedConstPtr = getCIntPtr();
|
|
int &TypedRef = *getIntPtr();
|
|
const int &TypedConstRef = *getCIntPtr();
|
|
|
|
// make sure check disregards auto types that aren't pointers or references
|
|
auto AutoInt = getInt();
|
|
|
|
auto NakedPtr = getIntPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto NakedPtr' can be declared as 'auto *NakedPtr'
|
|
// CHECK-FIXES: {{^}} auto *NakedPtr = getIntPtr();
|
|
auto NakedCPtr = getCIntPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto NakedCPtr' can be declared as 'const auto *NakedCPtr'
|
|
// CHECK-FIXES: {{^}} const auto *NakedCPtr = getCIntPtr();
|
|
|
|
const auto ConstPtr = getIntPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'const auto ConstPtr' can be declared as 'auto *const ConstPtr'
|
|
// CHECK-FIXES: {{^}} auto *const ConstPtr = getIntPtr();
|
|
const auto ConstCPtr = getCIntPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'const auto ConstCPtr' can be declared as 'const auto *const ConstCPtr'
|
|
// CHECK-FIXES: {{^}} const auto *const ConstCPtr = getCIntPtr();
|
|
|
|
volatile auto VolatilePtr = getIntPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'volatile auto VolatilePtr' can be declared as 'auto *volatile VolatilePtr'
|
|
// CHECK-FIXES: {{^}} auto *volatile VolatilePtr = getIntPtr();
|
|
volatile auto VolatileCPtr = getCIntPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'volatile auto VolatileCPtr' can be declared as 'const auto *volatile VolatileCPtr'
|
|
// CHECK-FIXES: {{^}} const auto *volatile VolatileCPtr = getCIntPtr();
|
|
|
|
auto *QualPtr = getIntPtr();
|
|
auto *QualCPtr = getCIntPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto *QualCPtr' can be declared as 'const auto *QualCPtr'
|
|
// CHECK-FIXES: {{^}} const auto *QualCPtr = getCIntPtr();
|
|
auto *const ConstantQualCPtr = getCIntPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto *const ConstantQualCPtr' can be declared as 'const auto *const ConstantQualCPtr'
|
|
// CHECK-FIXES: {{^}} const auto *const ConstantQualCPtr = getCIntPtr();
|
|
auto *volatile VolatileQualCPtr = getCIntPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto *volatile VolatileQualCPtr' can be declared as 'const auto *volatile VolatileQualCPtr'
|
|
// CHECK-FIXES: {{^}} const auto *volatile VolatileQualCPtr = getCIntPtr();
|
|
const auto *ConstQualCPtr = getCIntPtr();
|
|
|
|
auto &Ref = *getIntPtr();
|
|
auto &CRef = *getCIntPtr();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto &CRef' can be declared as 'const auto &CRef'
|
|
// CHECK-FIXES: {{^}} const auto &CRef = *getCIntPtr();
|
|
const auto &ConstCRef = *getCIntPtr();
|
|
|
|
if (auto X = getCIntPtr()) {
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: 'auto X' can be declared as 'const auto *X'
|
|
// CHECK-FIXES: {{^}} if (const auto *X = getCIntPtr()) {
|
|
}
|
|
}
|
|
|
|
void macroTest() {
|
|
#define _AUTO auto
|
|
#define _CONST const
|
|
_AUTO AutoMACROPtr = getIntPtr();
|
|
const _AUTO ConstAutoMacroPtr = getIntPtr();
|
|
_CONST _AUTO ConstMacroAutoMacroPtr = getIntPtr();
|
|
_CONST auto ConstMacroAutoPtr = getIntPtr();
|
|
#undef _AUTO
|
|
#undef _CONST
|
|
}
|
|
|
|
namespace std {
|
|
template <typename T>
|
|
class vector { // dummy impl
|
|
T _data[1];
|
|
|
|
public:
|
|
T *begin() { return _data; }
|
|
const T *begin() const { return _data; }
|
|
T *end() { return &_data[1]; }
|
|
const T *end() const { return &_data[1]; }
|
|
};
|
|
} // namespace std
|
|
|
|
void change(int &);
|
|
void observe(const int &);
|
|
|
|
void loopRef(std::vector<int> &Mutate, const std::vector<int> &Constant) {
|
|
for (auto &Data : Mutate) {
|
|
change(Data);
|
|
}
|
|
for (auto &Data : Constant) {
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto &Data' can be declared as 'const auto &Data'
|
|
// CHECK-FIXES: {{^}} for (const auto &Data : Constant) {
|
|
observe(Data);
|
|
}
|
|
}
|
|
|
|
void loopPtr(const std::vector<int *> &Mutate, const std::vector<const int *> &Constant) {
|
|
for (auto Data : Mutate) {
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto Data' can be declared as 'auto *Data'
|
|
// CHECK-FIXES: {{^}} for (auto *Data : Mutate) {
|
|
change(*Data);
|
|
}
|
|
for (auto Data : Constant) {
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto Data' can be declared as 'const auto *Data'
|
|
// CHECK-FIXES: {{^}} for (const auto *Data : Constant) {
|
|
observe(*Data);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void tempLoopPtr(std::vector<T *> &MutateTemplate, std::vector<const T *> &ConstantTemplate) {
|
|
for (auto Data : MutateTemplate) {
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto Data' can be declared as 'auto *Data'
|
|
// CHECK-FIXES: {{^}} for (auto *Data : MutateTemplate) {
|
|
change(*Data);
|
|
}
|
|
//FixMe
|
|
for (auto Data : ConstantTemplate) {
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto Data' can be declared as 'const auto *Data'
|
|
// CHECK-FIXES: {{^}} for (const auto *Data : ConstantTemplate) {
|
|
observe(*Data);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
class TemplateLoopPtr {
|
|
public:
|
|
void operator()(const std::vector<T *> &MClassTemplate, const std::vector<const T *> &CClassTemplate) {
|
|
for (auto Data : MClassTemplate) {
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: 'auto Data' can be declared as 'auto *Data'
|
|
// CHECK-FIXES: {{^}} for (auto *Data : MClassTemplate) {
|
|
change(*Data);
|
|
}
|
|
//FixMe
|
|
for (auto Data : CClassTemplate) {
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: 'auto Data' can be declared as 'const auto *Data'
|
|
// CHECK-FIXES: {{^}} for (const auto *Data : CClassTemplate) {
|
|
observe(*Data);
|
|
}
|
|
}
|
|
};
|
|
|
|
void bar() {
|
|
std::vector<int> Vec;
|
|
std::vector<int *> PtrVec;
|
|
std::vector<const int *> CPtrVec;
|
|
loopRef(Vec, Vec);
|
|
loopPtr(PtrVec, CPtrVec);
|
|
tempLoopPtr(PtrVec, CPtrVec);
|
|
TemplateLoopPtr<int>()(PtrVec, CPtrVec);
|
|
}
|
|
|
|
typedef int *(*functionRetPtr)();
|
|
typedef int (*functionRetVal)();
|
|
|
|
functionRetPtr getPtrFunction();
|
|
functionRetVal getValFunction();
|
|
|
|
void baz() {
|
|
auto MyFunctionPtr = getPtrFunction();
|
|
// CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: 'auto MyFunctionPtr' can be declared as 'auto *MyFunctionPtr'
|
|
// CHECK-FIXES-NOT: {{^}} auto *MyFunctionPtr = getPtrFunction();
|
|
auto MyFunctionVal = getValFunction();
|
|
// CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: 'auto MyFunctionVal' can be declared as 'auto *MyFunctionVal'
|
|
// CHECK-FIXES-NOT: {{^}} auto *MyFunctionVal = getValFunction();
|
|
|
|
auto LambdaTest = [] { return 0; };
|
|
// CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: 'auto LambdaTest' can be declared as 'auto *LambdaTest'
|
|
// CHECK-FIXES-NOT: {{^}} auto *LambdaTest = [] { return 0; };
|
|
|
|
auto LambdaTest2 = +[] { return 0; };
|
|
// CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: 'auto LambdaTest2' can be declared as 'auto *LambdaTest2'
|
|
// CHECK-FIXES-NOT: {{^}} auto *LambdaTest2 = +[] { return 0; };
|
|
|
|
auto MyFunctionRef = *getPtrFunction();
|
|
// CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: 'auto MyFunctionRef' can be declared as 'auto *MyFunctionRef'
|
|
// CHECK-FIXES-NOT: {{^}} auto *MyFunctionRef = *getPtrFunction();
|
|
|
|
auto &MyFunctionRef2 = *getPtrFunction();
|
|
}
|