forked from OSchip/llvm-project
861 lines
28 KiB
C++
861 lines
28 KiB
C++
// RUN: %check_clang_tidy %s modernize-loop-convert %t -- -- -I %S/Inputs/modernize-loop-convert
|
|
|
|
#include "structures.h"
|
|
|
|
namespace Array {
|
|
|
|
const int N = 6;
|
|
const int NMinusOne = N - 1;
|
|
int Arr[N] = {1, 2, 3, 4, 5, 6};
|
|
const int ConstArr[N] = {1, 2, 3, 4, 5, 6};
|
|
int (*PArr)[N] = &Arr;
|
|
|
|
void f() {
|
|
int Sum = 0;
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
Sum += Arr[I];
|
|
int K;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead [modernize-loop-convert]
|
|
// CHECK-FIXES: for (int I : Arr)
|
|
// CHECK-FIXES-NEXT: Sum += I;
|
|
// CHECK-FIXES-NEXT: int K;
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("Fibonacci number is %d\n", Arr[I]);
|
|
Sum += Arr[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : Arr)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
int X = Arr[I];
|
|
int Y = Arr[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : Arr)
|
|
// CHECK-FIXES-NEXT: int X = I;
|
|
// CHECK-FIXES-NEXT: int Y = I + 2;
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
int X = N;
|
|
X = Arr[I];
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : Arr)
|
|
// CHECK-FIXES-NEXT: int X = N;
|
|
// CHECK-FIXES-NEXT: X = I;
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
Arr[I] += 1;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & I : Arr)
|
|
// CHECK-FIXES-NEXT: I += 1;
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
int X = Arr[I] + 2;
|
|
Arr[I]++;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & I : Arr)
|
|
// CHECK-FIXES-NEXT: int X = I + 2;
|
|
// CHECK-FIXES-NEXT: I++;
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
Arr[I] = 4 + Arr[I];
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & I : Arr)
|
|
// CHECK-FIXES-NEXT: I = 4 + I;
|
|
|
|
for (int I = 0; I < NMinusOne + 1; ++I) {
|
|
Sum += Arr[I];
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : Arr)
|
|
// CHECK-FIXES-NEXT: Sum += I;
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("Fibonacci number %d has address %p\n", Arr[I], &Arr[I]);
|
|
Sum += Arr[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & I : Arr)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number %d has address %p\n", I, &I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
Val Teas[N];
|
|
for (int I = 0; I < N; ++I) {
|
|
Teas[I].g();
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & Tea : Teas)
|
|
// CHECK-FIXES-NEXT: Tea.g();
|
|
|
|
for (int I = 0; N > I; ++I) {
|
|
printf("Fibonacci number %d has address %p\n", Arr[I], &Arr[I]);
|
|
Sum += Arr[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & I : Arr)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number %d has address %p\n", I, &I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
for (int I = 0; N != I; ++I) {
|
|
printf("Fibonacci number %d has address %p\n", Arr[I], &Arr[I]);
|
|
Sum += Arr[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & I : Arr)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number %d has address %p\n", I, &I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
for (int I = 0; I != N; ++I) {
|
|
printf("Fibonacci number %d has address %p\n", Arr[I], &Arr[I]);
|
|
Sum += Arr[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & I : Arr)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number %d has address %p\n", I, &I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
}
|
|
|
|
const int *constArray() {
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("2 * %d = %d\n", ConstArr[I], ConstArr[I] + ConstArr[I]);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : ConstArr)
|
|
// CHECK-FIXES-NEXT: printf("2 * %d = %d\n", I, I + I);
|
|
|
|
const NonTriviallyCopyable NonCopy[N]{};
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("2 * %d = %d\n", NonCopy[I].X, NonCopy[I].X + NonCopy[I].X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (const auto & I : NonCopy)
|
|
// CHECK-FIXES-NEXT: printf("2 * %d = %d\n", I.X, I.X + I.X);
|
|
|
|
const TriviallyCopyableButBig Big[N]{};
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("2 * %d = %d\n", Big[I].X, Big[I].X + Big[I].X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (const auto & I : Big)
|
|
// CHECK-FIXES-NEXT: printf("2 * %d = %d\n", I.X, I.X + I.X);
|
|
|
|
bool Something = false;
|
|
for (int I = 0; I < N; ++I) {
|
|
if (Something)
|
|
return &ConstArr[I];
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (const int & I : ConstArr)
|
|
// CHECK-FIXES-NEXT: if (Something)
|
|
// CHECK-FIXES-NEXT: return &I;
|
|
}
|
|
|
|
struct HasArr {
|
|
int Arr[N];
|
|
Val ValArr[N];
|
|
void implicitThis() {
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("%d", Arr[I]);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : Arr)
|
|
// CHECK-FIXES-NEXT: printf("%d", I);
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("%d", ValArr[I].X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : ValArr)
|
|
// CHECK-FIXES-NEXT: printf("%d", I.X);
|
|
}
|
|
|
|
void explicitThis() {
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("%d", this->Arr[I]);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : this->Arr)
|
|
// CHECK-FIXES-NEXT: printf("%d", I);
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("%d", this->ValArr[I].X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : this->ValArr)
|
|
// CHECK-FIXES-NEXT: printf("%d", I.X);
|
|
}
|
|
};
|
|
|
|
struct HasIndirectArr {
|
|
HasArr HA;
|
|
void implicitThis() {
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("%d", HA.Arr[I]);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : HA.Arr)
|
|
// CHECK-FIXES-NEXT: printf("%d", I);
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("%d", HA.ValArr[I].X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : HA.ValArr)
|
|
// CHECK-FIXES-NEXT: printf("%d", I.X);
|
|
}
|
|
|
|
void explicitThis() {
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("%d", this->HA.Arr[I]);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : this->HA.Arr)
|
|
// CHECK-FIXES-NEXT: printf("%d", I);
|
|
|
|
for (int I = 0; I < N; ++I) {
|
|
printf("%d", this->HA.ValArr[I].X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : this->HA.ValArr)
|
|
// CHECK-FIXES-NEXT: printf("%d", I.X);
|
|
}
|
|
};
|
|
|
|
// Loops whose bounds are value-dependent should not be converted.
|
|
template <int N>
|
|
void dependentExprBound() {
|
|
for (int I = 0; I < N; ++I)
|
|
Arr[I] = 0;
|
|
}
|
|
template void dependentExprBound<20>();
|
|
|
|
void memberFunctionPointer() {
|
|
Val V;
|
|
void (Val::*mfpArr[N])(void) = {&Val::g};
|
|
for (int I = 0; I < N; ++I)
|
|
(V.*mfpArr[I])();
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : mfpArr)
|
|
// CHECK-FIXES-NEXT: (V.*I)();
|
|
|
|
struct Foo {
|
|
int (Val::*f)();
|
|
} Foo[N];
|
|
|
|
for (int I = 0; I < N; ++I)
|
|
int R = (V.*(Foo[I].f))();
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : Foo)
|
|
// CHECK-FIXES-NEXT: int R = (V.*(I.f))();
|
|
|
|
}
|
|
|
|
} // namespace Array
|
|
|
|
namespace Iterator {
|
|
|
|
void f() {
|
|
/// begin()/end() - based for loops here:
|
|
T Tt;
|
|
for (T::iterator It = Tt.begin(), E = Tt.end(); It != E; ++It) {
|
|
printf("I found %d\n", *It);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & It : Tt)
|
|
// CHECK-FIXES-NEXT: printf("I found %d\n", It);
|
|
|
|
// Do not crash because of Qq.begin() converting. Q::iterator converts with a
|
|
// conversion operator, which has no name, to Q::const_iterator.
|
|
Q Qq;
|
|
for (Q::const_iterator It = Qq.begin(), E = Qq.end(); It != E; ++It) {
|
|
printf("I found %d\n", *It);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & It : Qq)
|
|
// CHECK-FIXES-NEXT: printf("I found %d\n", It);
|
|
|
|
T *Pt;
|
|
for (T::iterator It = Pt->begin(), E = Pt->end(); It != E; ++It) {
|
|
printf("I found %d\n", *It);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & It : *Pt)
|
|
// CHECK-FIXES-NEXT: printf("I found %d\n", It);
|
|
|
|
S Ss;
|
|
for (S::iterator It = Ss.begin(), E = Ss.end(); It != E; ++It) {
|
|
printf("s has value %d\n", (*It).X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & It : Ss)
|
|
// CHECK-FIXES-NEXT: printf("s has value %d\n", It.X);
|
|
|
|
S *Ps;
|
|
for (S::iterator It = Ps->begin(), E = Ps->end(); It != E; ++It) {
|
|
printf("s has value %d\n", (*It).X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & P : *Ps)
|
|
// CHECK-FIXES-NEXT: printf("s has value %d\n", P.X);
|
|
|
|
for (S::const_iterator It = Ss.cbegin(), E = Ss.cend(); It != E; ++It) {
|
|
printf("s has value %d\n", (*It).X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto It : Ss)
|
|
// CHECK-FIXES-NEXT: printf("s has value %d\n", It.X);
|
|
|
|
for (S::iterator It = Ss.begin(), E = Ss.end(); It != E; ++It) {
|
|
printf("s has value %d\n", It->X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & It : Ss)
|
|
// CHECK-FIXES-NEXT: printf("s has value %d\n", It.X);
|
|
|
|
for (S::iterator It = Ss.begin(), E = Ss.end(); It != E; ++It) {
|
|
It->X = 3;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & It : Ss)
|
|
// CHECK-FIXES-NEXT: It.X = 3;
|
|
|
|
for (S::iterator It = Ss.begin(), E = Ss.end(); It != E; ++It) {
|
|
(*It).X = 3;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & It : Ss)
|
|
// CHECK-FIXES-NEXT: It.X = 3;
|
|
|
|
for (S::iterator It = Ss.begin(), E = Ss.end(); It != E; ++It) {
|
|
It->nonConstFun(4, 5);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & It : Ss)
|
|
// CHECK-FIXES-NEXT: It.nonConstFun(4, 5);
|
|
|
|
U Uu;
|
|
for (U::iterator It = Uu.begin(), E = Uu.end(); It != E; ++It) {
|
|
printf("s has value %d\n", It->X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & It : Uu)
|
|
// CHECK-FIXES-NEXT: printf("s has value %d\n", It.X);
|
|
|
|
for (U::iterator It = Uu.begin(), E = Uu.end(); It != E; ++It) {
|
|
printf("s has value %d\n", (*It).X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & It : Uu)
|
|
// CHECK-FIXES-NEXT: printf("s has value %d\n", It.X);
|
|
|
|
for (U::iterator It = Uu.begin(), E = Uu.end(); It != E; ++It) {
|
|
Val* a = It.operator->();
|
|
}
|
|
|
|
U::iterator A;
|
|
for (U::iterator I = Uu.begin(), E = Uu.end(); I != E; ++I)
|
|
int K = A->X + I->X;
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : Uu)
|
|
// CHECK-FIXES-NEXT: int K = A->X + I.X;
|
|
|
|
dependent<int> V;
|
|
for (dependent<int>::iterator It = V.begin(), E = V.end();
|
|
It != E; ++It) {
|
|
printf("Fibonacci number is %d\n", *It);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & It : V)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", It);
|
|
|
|
for (dependent<int>::iterator It(V.begin()), E = V.end();
|
|
It != E; ++It) {
|
|
printf("Fibonacci number is %d\n", *It);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & It : V)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", It);
|
|
|
|
doublyDependent<int, int> Intmap;
|
|
for (doublyDependent<int, int>::iterator It = Intmap.begin(), E = Intmap.end();
|
|
It != E; ++It) {
|
|
printf("Intmap[%d] = %d", It->first, It->second);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & It : Intmap)
|
|
// CHECK-FIXES: printf("Intmap[%d] = %d", It.first, It.second);
|
|
|
|
// PtrSet's iterator dereferences by value so auto & can't be used.
|
|
{
|
|
PtrSet<int *> Val_int_ptrs;
|
|
for (PtrSet<int *>::iterator I = Val_int_ptrs.begin(),
|
|
E = Val_int_ptrs.end();
|
|
I != E; ++I) {
|
|
(void) *I;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-5]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto Val_int_ptr : Val_int_ptrs)
|
|
}
|
|
|
|
// This container uses an iterator where the dereference type is a typedef of
|
|
// a reference type. Make sure non-const auto & is still used. A failure here
|
|
// means canonical types aren't being tested.
|
|
{
|
|
TypedefDerefContainer<int> Int_ptrs;
|
|
for (TypedefDerefContainer<int>::iterator I = Int_ptrs.begin(),
|
|
E = Int_ptrs.end();
|
|
I != E; ++I) {
|
|
(void) *I;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-5]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int & Int_ptr : Int_ptrs)
|
|
}
|
|
|
|
{
|
|
// Iterators returning an rvalue reference should disqualify the loop from
|
|
// transformation.
|
|
RValueDerefContainer<int> Container;
|
|
for (RValueDerefContainer<int>::iterator I = Container.begin(),
|
|
E = Container.end();
|
|
I != E; ++I) {
|
|
(void) *I;
|
|
}
|
|
}
|
|
|
|
dependent<Val *> Dpp;
|
|
for (dependent<Val *>::iterator I = Dpp.begin(), E = Dpp.end(); I != E; ++I) {
|
|
printf("%d\n", (**I).X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : Dpp)
|
|
// CHECK-FIXES-NEXT: printf("%d\n", (*I).X);
|
|
|
|
for (dependent<Val *>::iterator I = Dpp.begin(), E = Dpp.end(); I != E; ++I) {
|
|
printf("%d\n", (*I)->X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : Dpp)
|
|
// CHECK-FIXES-NEXT: printf("%d\n", I->X);
|
|
}
|
|
|
|
// Tests to verify the proper use of auto where the init variable type and the
|
|
// initializer type differ or are mostly the same except for const qualifiers.
|
|
void different_type() {
|
|
// Ss.begin() returns a type 'iterator' which is just a non-const pointer and
|
|
// differs from const_iterator only on the const qualification.
|
|
S Ss;
|
|
for (S::const_iterator It = Ss.begin(), E = Ss.end(); It != E; ++It) {
|
|
printf("s has value %d\n", (*It).X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto It : Ss)
|
|
// CHECK-FIXES-NEXT: printf("s has value %d\n", It.X);
|
|
|
|
S *Ps;
|
|
for (S::const_iterator It = Ps->begin(), E = Ps->end(); It != E; ++It) {
|
|
printf("s has value %d\n", (*It).X);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto P : *Ps)
|
|
// CHECK-FIXES-NEXT: printf("s has value %d\n", P.X);
|
|
|
|
dependent<int> V;
|
|
for (dependent<int>::const_iterator It = V.begin(), E = V.end();
|
|
It != E; ++It) {
|
|
printf("Fibonacci number is %d\n", *It);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int It : V)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", It);
|
|
|
|
for (dependent<int>::const_iterator It(V.begin()), E = V.end();
|
|
It != E; ++It) {
|
|
printf("Fibonacci number is %d\n", *It);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int It : V)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", It);
|
|
}
|
|
|
|
// Tests to ensure that an implicit 'this' is picked up as the container.
|
|
// If member calls are made to 'this' within the loop, the transform becomes
|
|
// risky as these calls may affect state that affects the loop.
|
|
class C {
|
|
public:
|
|
typedef MutableVal *iterator;
|
|
typedef const MutableVal *const_iterator;
|
|
|
|
iterator begin();
|
|
iterator end();
|
|
const_iterator begin() const;
|
|
const_iterator end() const;
|
|
|
|
void doSomething();
|
|
void doSomething() const;
|
|
|
|
void doLoop() {
|
|
for (iterator I = begin(), E = end(); I != E; ++I)
|
|
(void) *I;
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : *this)
|
|
|
|
for (iterator I = C::begin(), E = C::end(); I != E; ++I)
|
|
(void) *I;
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : *this)
|
|
|
|
for (iterator I = begin(), E = end(); I != E; ++I) {
|
|
(void) *I;
|
|
doSomething();
|
|
}
|
|
|
|
for (iterator I = begin(); I != end(); ++I)
|
|
(void) *I;
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : *this)
|
|
|
|
for (iterator I = begin(); I != end(); ++I) {
|
|
(void) *I;
|
|
doSomething();
|
|
}
|
|
}
|
|
|
|
void doLoop() const {
|
|
for (const_iterator I = begin(), E = end(); I != E; ++I)
|
|
(void) *I;
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto I : *this)
|
|
|
|
for (const_iterator I = C::begin(), E = C::end(); I != E; ++I)
|
|
(void) *I;
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto I : *this)
|
|
|
|
for (const_iterator I = begin(), E = end(); I != E; ++I) {
|
|
(void) *I;
|
|
doSomething();
|
|
}
|
|
}
|
|
};
|
|
|
|
class C2 {
|
|
public:
|
|
typedef MutableVal *iterator;
|
|
|
|
iterator begin() const;
|
|
iterator end() const;
|
|
|
|
void doLoop() {
|
|
// The implicit 'this' will have an Implicit cast to const C2* wrapped
|
|
// around it. Make sure the replacement still happens.
|
|
for (iterator I = begin(), E = end(); I != E; ++I)
|
|
(void) *I;
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:5: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (auto & I : *this)
|
|
}
|
|
};
|
|
|
|
} // namespace Iterator
|
|
|
|
namespace PseudoArray {
|
|
|
|
const int N = 6;
|
|
dependent<int> V;
|
|
dependent<int> *Pv;
|
|
const dependent<NonTriviallyCopyable> Constv;
|
|
const dependent<NonTriviallyCopyable> *Pconstv;
|
|
|
|
transparent<dependent<int>> Cv;
|
|
|
|
void f() {
|
|
int Sum = 0;
|
|
for (int I = 0, E = V.size(); I < E; ++I) {
|
|
printf("Fibonacci number is %d\n", V[I]);
|
|
Sum += V[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : V)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
for (int I = 0, E = V.size(); I < E; ++I) {
|
|
printf("Fibonacci number is %d\n", V.at(I));
|
|
Sum += V.at(I) + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : V)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
for (int I = 0, E = Pv->size(); I < E; ++I) {
|
|
printf("Fibonacci number is %d\n", Pv->at(I));
|
|
Sum += Pv->at(I) + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : *Pv)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
// This test will fail if size() isn't called repeatedly, since it
|
|
// returns unsigned int, and 0 is deduced to be signed int.
|
|
// FIXME: Insert the necessary explicit conversion, or write out the types
|
|
// explicitly.
|
|
for (int I = 0; I < Pv->size(); ++I) {
|
|
printf("Fibonacci number is %d\n", (*Pv).at(I));
|
|
Sum += (*Pv)[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : *Pv)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
for (int I = 0; I < Cv->size(); ++I) {
|
|
printf("Fibonacci number is %d\n", Cv->at(I));
|
|
Sum += Cv->at(I) + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : *Cv)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
for (int I = 0, E = V.size(); E > I; ++I) {
|
|
printf("Fibonacci number is %d\n", V[I]);
|
|
Sum += V[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : V)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
for (int I = 0, E = V.size(); I != E; ++I) {
|
|
printf("Fibonacci number is %d\n", V[I]);
|
|
Sum += V[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : V)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
|
|
for (int I = 0, E = V.size(); E != I; ++I) {
|
|
printf("Fibonacci number is %d\n", V[I]);
|
|
Sum += V[I] + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : V)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I);
|
|
// CHECK-FIXES-NEXT: Sum += I + 2;
|
|
}
|
|
|
|
// Ensure that 'const auto &' is used with containers of non-trivial types.
|
|
void constness() {
|
|
int Sum = 0;
|
|
for (int I = 0, E = Constv.size(); I < E; ++I) {
|
|
printf("Fibonacci number is %d\n", Constv[I].X);
|
|
Sum += Constv[I].X + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (const auto & I : Constv)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I.X);
|
|
// CHECK-FIXES-NEXT: Sum += I.X + 2;
|
|
|
|
for (int I = 0, E = Constv.size(); I < E; ++I) {
|
|
printf("Fibonacci number is %d\n", Constv.at(I).X);
|
|
Sum += Constv.at(I).X + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (const auto & I : Constv)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I.X);
|
|
// CHECK-FIXES-NEXT: Sum += I.X + 2;
|
|
|
|
for (int I = 0, E = Pconstv->size(); I < E; ++I) {
|
|
printf("Fibonacci number is %d\n", Pconstv->at(I).X);
|
|
Sum += Pconstv->at(I).X + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (const auto & I : *Pconstv)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I.X);
|
|
// CHECK-FIXES-NEXT: Sum += I.X + 2;
|
|
|
|
// This test will fail if size() isn't called repeatedly, since it
|
|
// returns unsigned int, and 0 is deduced to be signed int.
|
|
// FIXME: Insert the necessary explicit conversion, or write out the types
|
|
// explicitly.
|
|
for (int I = 0; I < Pconstv->size(); ++I) {
|
|
printf("Fibonacci number is %d\n", (*Pconstv).at(I).X);
|
|
Sum += (*Pconstv)[I].X + 2;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (const auto & I : *Pconstv)
|
|
// CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", I.X);
|
|
// CHECK-FIXES-NEXT: Sum += I.X + 2;
|
|
}
|
|
|
|
void constRef(const dependent<int>& ConstVRef) {
|
|
int sum = 0;
|
|
// FIXME: This does not work with size_t (probably due to the implementation
|
|
// of dependent); make dependent work exactly like a std container type.
|
|
for (int I = 0; I < ConstVRef.size(); ++I) {
|
|
sum += ConstVRef[I];
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : ConstVRef)
|
|
// CHECK-FIXES-NEXT: sum += I;
|
|
|
|
for (auto I = ConstVRef.begin(), E = ConstVRef.end(); I != E; ++I) {
|
|
sum += *I;
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (int I : ConstVRef)
|
|
// CHECK-FIXES-NEXT: sum += I;
|
|
}
|
|
|
|
// Check for loops that don't mention containers.
|
|
void noContainer() {
|
|
for (auto I = 0; I < V.size(); ++I) {
|
|
}
|
|
|
|
for (auto I = 0; I < V.size(); ++I)
|
|
;
|
|
}
|
|
|
|
struct NoBeginEnd {
|
|
unsigned size() const;
|
|
unsigned& operator[](int);
|
|
const unsigned& operator[](int) const;
|
|
};
|
|
|
|
struct NoConstBeginEnd {
|
|
NoConstBeginEnd();
|
|
unsigned size() const;
|
|
unsigned* begin();
|
|
unsigned* end();
|
|
unsigned& operator[](int);
|
|
const unsigned& operator[](int) const;
|
|
};
|
|
|
|
struct ConstBeginEnd {
|
|
ConstBeginEnd();
|
|
unsigned size() const;
|
|
unsigned* begin() const;
|
|
unsigned* end() const;
|
|
unsigned& operator[](int);
|
|
const unsigned& operator[](int) const;
|
|
};
|
|
|
|
// Shouldn't transform pseudo-array uses if the container doesn't provide
|
|
// begin() and end() of the right const-ness.
|
|
void NoBeginEndTest() {
|
|
NoBeginEnd NBE;
|
|
for (unsigned I = 0, E = NBE.size(); I < E; ++I)
|
|
printf("%d\n", NBE[I]);
|
|
|
|
const NoConstBeginEnd Const_NCBE;
|
|
for (unsigned I = 0, E = Const_NCBE.size(); I < E; ++I)
|
|
printf("%d\n", Const_NCBE[I]);
|
|
|
|
ConstBeginEnd CBE;
|
|
for (unsigned I = 0, E = CBE.size(); I < E; ++I)
|
|
printf("%d\n", CBE[I]);
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (unsigned int I : CBE)
|
|
// CHECK-FIXES-NEXT: printf("%d\n", I);
|
|
|
|
const ConstBeginEnd Const_CBE;
|
|
for (unsigned I = 0, E = Const_CBE.size(); I < E; ++I)
|
|
printf("%d\n", Const_CBE[I]);
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (unsigned int I : Const_CBE)
|
|
// CHECK-FIXES-NEXT: printf("%d\n", I);
|
|
}
|
|
|
|
struct DerefByValue {
|
|
DerefByValue();
|
|
struct iter { unsigned operator*(); };
|
|
unsigned size() const;
|
|
iter begin();
|
|
iter end();
|
|
unsigned operator[](int);
|
|
};
|
|
|
|
void derefByValueTest() {
|
|
DerefByValue DBV;
|
|
for (unsigned I = 0, E = DBV.size(); I < E; ++I) {
|
|
printf("%d\n", DBV[I]);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (unsigned int I : DBV)
|
|
// CHECK-FIXES-NEXT: printf("%d\n", I);
|
|
|
|
for (unsigned I = 0, E = DBV.size(); I < E; ++I) {
|
|
auto f = [DBV, I]() {};
|
|
printf("%d\n", DBV[I]);
|
|
}
|
|
// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (unsigned int I : DBV)
|
|
// CHECK-FIXES-NEXT: auto f = [DBV, &I]() {};
|
|
// CHECK-FIXES-NEXT: printf("%d\n", I);
|
|
}
|
|
|
|
void fundamentalTypesTest() {
|
|
const int N = 10;
|
|
bool Bools[N];
|
|
for (int i = 0; i < N; ++i)
|
|
printf("%d", Bools[i]);
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (bool Bool : Bools)
|
|
|
|
int Ints[N];
|
|
unsigned short int Shorts[N];
|
|
for (int i = 0; i < N; ++i)
|
|
printf("%d", Shorts[i]);
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (unsigned short Short : Shorts)
|
|
|
|
signed long Longs[N];
|
|
for (int i = 0; i < N; ++i)
|
|
printf("%d", Longs[i]);
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (long Long : Longs)
|
|
|
|
long long int LongLongs[N];
|
|
for (int i = 0; i < N; ++i)
|
|
printf("%d", LongLongs[i]);
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (long long LongLong : LongLongs)
|
|
|
|
char Chars[N];
|
|
for (int i = 0; i < N; ++i)
|
|
printf("%d", Chars[i]);
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (char Char : Chars)
|
|
|
|
wchar_t WChars[N];
|
|
for (int i = 0; i < N; ++i)
|
|
printf("%d", WChars[i]);
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (wchar_t WChar : WChars)
|
|
|
|
float Floats[N];
|
|
for (int i = 0; i < N; ++i)
|
|
printf("%d", Floats[i]);
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (float Float : Floats)
|
|
|
|
double Doubles[N];
|
|
for (int i = 0; i < N; ++i)
|
|
printf("%d", Doubles[i]);
|
|
// CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
|
|
// CHECK-FIXES: for (double Double : Doubles)
|
|
}
|
|
|
|
} // namespace PseudoArray
|