Don't use "auto" on loops over fundamental types in modernize-loop-convert.

[angelgarcia]

Summary

using "auto" on a loop that iterates over ints is kind of an overkill. Use the real type name instead.

[angelgarcia]

Add a guard to check that ElemType is not null.

[klimek]

lg

clang-tidy/modernize/LoopConvertCheck.h

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   struct RangeDescriptor {
     RangeDescriptor();
     bool ContainerNeedsDereference;
     bool DerefByConstRef;
     bool DerefByValue;
-    bool IsTriviallyCopyable;
     std::string ContainerString;
+    QualType ElemType;
   };
 
   void getAliasRange(SourceManager &SM, SourceRange &DeclRange);
 
   void doConversion(ASTContext *Context, const VarDecl *IndexVar,
                     const VarDecl *MaybeContainer, const UsageResult &Usages,
                     const DeclStmt *AliasDecl, bool AliasUseRequired,
                     bool AliasFromForInit, const ForStmt *Loop,

clang-tidy/modernize/LoopConvertCheck.cpp

if (const auto *VDec = getReferencedVariable(ContainerExpr)) {
     CType = CType.getNonReferenceType();
     return CType.isConstQualified();
   }
   return false;
 }
 
 LoopConvertCheck::RangeDescriptor::RangeDescriptor()
     : ContainerNeedsDereference(false), DerefByConstRef(false),
-      DerefByValue(false), IsTriviallyCopyable(false) {}
+      DerefByValue(false) {}
 
 LoopConvertCheck::LoopConvertCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), TUInfo(new TUTrackingInfo),
       MinConfidence(StringSwitch<Confidence::Level>(
                         Options.get("MinConfidence", "reasonable"))
                         .Case("safe", Confidence::CL_Safe)
                         .Case("risky", Confidence::CL_Risky)
                         .Default(Confidence::CL_Reasonable)),
for (const auto &Usage : Usages) {
       Diag << FixItHint::CreateReplacement(
           CharSourceRange::getTokenRange(Range), ReplaceText);
     }
   }
 
   // Now, we need to construct the new range expression.
   SourceRange ParenRange(Loop->getLParenLoc(), Loop->getRParenLoc());
 
-  QualType AutoType = Context->getAutoDeductType();
+  QualType Type = Context->getAutoDeductType();
+  if (!Descriptor.ElemType.isNull() && Descriptor.ElemType->isFundamentalType())
+    Type = Descriptor.ElemType.getUnqualifiedType();
 
   // If the new variable name is from the aliased variable, then the reference
   // type for the new variable should only be used if the aliased variable was
   // declared as a reference.
+  bool IsTriviallyCopyable =
+      !Descriptor.ElemType.isNull() &&
+      Descriptor.ElemType.isTriviallyCopyableType(*Context);
   bool UseCopy =
-      CanCopy &&
-      ((VarNameFromAlias && !AliasVarIsRef) ||
-       (Descriptor.DerefByConstRef && Descriptor.IsTriviallyCopyable));
+      CanCopy && ((VarNameFromAlias && !AliasVarIsRef) ||
+                  (Descriptor.DerefByConstRef && IsTriviallyCopyable));
 
   if (!UseCopy) {
     if (Descriptor.DerefByConstRef) {
-      AutoType =
-          Context->getLValueReferenceType(Context->getConstType(AutoType));
+      Type = Context->getLValueReferenceType(Context->getConstType(Type));
     } else if (Descriptor.DerefByValue) {
-      if (!Descriptor.IsTriviallyCopyable)
-        AutoType = Context->getRValueReferenceType(AutoType);
+      if (!IsTriviallyCopyable)
+        Type = Context->getRValueReferenceType(Type);
     } else {
-      AutoType = Context->getLValueReferenceType(AutoType);
+      Type = Context->getLValueReferenceType(Type);
     }
   }
 
   StringRef MaybeDereference = Descriptor.ContainerNeedsDereference ? "*" : "";
-  std::string TypeString = AutoType.getAsString();
+  std::string TypeString = Type.getAsString(getLangOpts());
   std::string Range = ("(" + TypeString + " " + VarName + " : " +
                        MaybeDereference + Descriptor.ContainerString + ")")
                           .str();
   Diag << FixItHint::CreateReplacement(
       CharSourceRange::getTokenRange(ParenRange), Range);
   TUInfo->getGeneratedDecls().insert(make_pair(Loop, VarName));
 }
 
if (!U.Expression || U.Expression->getType().isNull())
       continue;
     QualType Type = U.Expression->getType().getCanonicalType();
     if (U.Kind == Usage::UK_MemberThroughArrow) {
       if (!Type->isPointerType()) {
         continue;
       }
       Type = Type->getPointeeType();
     }
-    Descriptor.IsTriviallyCopyable = Type.isTriviallyCopyableType(*Context);
+    Descriptor.ElemType = Type;
   }
 }
 
 /// \brief Determines what kind of 'auto' must be used after converting an
 /// iterator based for loop.
 void LoopConvertCheck::getIteratorLoopQualifiers(ASTContext *Context,
                                                  const BoundNodes &Nodes,
                                                  RangeDescriptor &Descriptor) {
   // The matchers for iterator loops provide bound nodes to obtain this
   // information.
   const auto *InitVar = Nodes.getDeclAs<VarDecl>(InitVarName);
   QualType CanonicalInitVarType = InitVar->getType().getCanonicalType();
   const auto *DerefByValueType =
       Nodes.getNodeAs<QualType>(DerefByValueResultName);
   Descriptor.DerefByValue = DerefByValueType;
 
   if (Descriptor.DerefByValue) {
     // If the dereference operator returns by value then test for the
     // canonical const qualification of the init variable type.
     Descriptor.DerefByConstRef = CanonicalInitVarType.isConstQualified();
-    Descriptor.IsTriviallyCopyable =
-        DerefByValueType->isTriviallyCopyableType(*Context);
+    Descriptor.ElemType = *DerefByValueType;
   } else {
     if (const auto *DerefType =
             Nodes.getNodeAs<QualType>(DerefByRefResultName)) {
       // A node will only be bound with DerefByRefResultName if we're dealing
       // with a user-defined iterator type. Test the const qualification of
       // the reference type.
       auto ValueType = DerefType->getNonReferenceType();
 
       Descriptor.DerefByConstRef = ValueType.isConstQualified();
-      Descriptor.IsTriviallyCopyable =
-          ValueType.isTriviallyCopyableType(*Context);
+      Descriptor.ElemType = ValueType;
     } else {
       // By nature of the matcher this case is triggered only for built-in
       // iterator types (i.e. pointers).
       assert(isa<PointerType>(CanonicalInitVarType) &&
              "Non-class iterator type is not a pointer type");
 
       // We test for const qualification of the pointed-at type.
       Descriptor.DerefByConstRef =
           CanonicalInitVarType->getPointeeType().isConstQualified();
-      Descriptor.IsTriviallyCopyable =
-          CanonicalInitVarType->getPointeeType().isTriviallyCopyableType(
-              *Context);
+      Descriptor.ElemType = CanonicalInitVarType->getPointeeType();
     }
   }
 }
 
 /// \brief Determines the parameters needed to build the range replacement.
 void LoopConvertCheck::determineRangeDescriptor(
     ASTContext *Context, const BoundNodes &Nodes, const ForStmt *Loop,
     LoopFixerKind FixerKind, const Expr *ContainerExpr,

test/clang-tidy/modernize-loop-convert-basic.cpp

 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 (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: Sum += Elem;
   // 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 (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
   // CHECK-FIXES-NEXT: Sum += Elem + 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 (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: int X = Elem;
   // CHECK-FIXES-NEXT: int Y = Elem + 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 (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: int X = N;
   // CHECK-FIXES-NEXT: X = Elem;
 
   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 (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: Elem += 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 (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: int X = Elem + 2;
   // CHECK-FIXES-NEXT: Elem++;
 
   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 (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: Elem = 4 + Elem;
 
   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 (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: Sum += Elem;
 
   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 (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: printf("Fibonacci number %d has address %p\n", Elem, &Elem);
   // CHECK-FIXES-NEXT: Sum += Elem + 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();
 }
 
 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 (auto Elem : ConstArr)
+  // CHECK-FIXES: for (int Elem : ConstArr)
   // CHECK-FIXES-NEXT: printf("2 * %d = %d\n", Elem, Elem + Elem);
 
   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 & Elem : NonCopy)
   // CHECK-FIXES-NEXT: printf("2 * %d = %d\n", Elem.X, Elem.X + Elem.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 auto & Elem : ConstArr)
+  // CHECK-FIXES: for (const int & Elem : ConstArr)
   // CHECK-FIXES-NEXT: if (Something)
   // CHECK-FIXES-NEXT: return &Elem;
 }
 
 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 (auto & Elem : Arr)
+    // CHECK-FIXES: for (int & Elem : Arr)
     // CHECK-FIXES-NEXT: printf("%d", Elem);
 
     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 & Elem : ValArr)
     // CHECK-FIXES-NEXT: printf("%d", Elem.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 (auto & Elem : this->Arr)
+    // CHECK-FIXES: for (int & Elem : this->Arr)
     // CHECK-FIXES-NEXT: printf("%d", Elem);
 
     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 & Elem : this->ValArr)
     // CHECK-FIXES-NEXT: printf("%d", Elem.X);

 
 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 (auto & Elem : Tt)
+  // CHECK-FIXES: for (int & Elem : Tt)
   // CHECK-FIXES-NEXT: printf("I found %d\n", Elem);
 
   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 (auto & Elem : *Pt)
+  // CHECK-FIXES: for (int & Elem : *Pt)
   // CHECK-FIXES-NEXT: printf("I found %d\n", Elem);
 
   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 & Elem : Ss)
void f() {
   // CHECK-FIXES-NEXT: int K = A->X + Elem.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 (auto & Elem : V)
+  // CHECK-FIXES: for (int & Elem : V)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
 
   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 (auto & Elem : V)
+  // CHECK-FIXES: for (int & Elem : V)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
 
   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
void f() {
   {
     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 (auto & Int_ptr : Int_ptrs)
+    // 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();

 
 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 (auto & Elem : V)
+  // CHECK-FIXES: for (int & Elem : V)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
   // CHECK-FIXES-NEXT: Sum += Elem + 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 (auto & Elem : V)
+  // CHECK-FIXES: for (int & Elem : V)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
   // CHECK-FIXES-NEXT: Sum += Elem + 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 (auto & Elem : *Pv)
+  // CHECK-FIXES: for (int & Elem : *Pv)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
   // CHECK-FIXES-NEXT: Sum += Elem + 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 (auto & Elem : *Pv)
+  // CHECK-FIXES: for (int & Elem : *Pv)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
   // CHECK-FIXES-NEXT: Sum += Elem + 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 (auto & Elem : *Cv)
+  // CHECK-FIXES: for (int & Elem : *Cv)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
   // CHECK-FIXES-NEXT: Sum += Elem + 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) {

 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 (auto Elem : ConstVRef)
+  // CHECK-FIXES: for (int Elem : ConstVRef)
   // CHECK-FIXES-NEXT: sum += Elem;
 
   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 (auto Elem : ConstVRef)
+  // CHECK-FIXES: for (int Elem : ConstVRef)
   // CHECK-FIXES-NEXT: sum += Elem;
 }
 
 // Check for loops that don't mention containers.
 void noContainer() {
   for (auto I = 0; I < V.size(); ++I) {
   }
 
void NoBeginEndTest() {
   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 (auto & Elem : CBE)
+  // CHECK-FIXES: for (unsigned int & Elem : CBE)
   // CHECK-FIXES-NEXT: printf("%d\n", Elem);
 
   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 (auto Elem : Const_CBE)
+  // CHECK-FIXES: for (unsigned int Elem : Const_CBE)
   // CHECK-FIXES-NEXT: printf("%d\n", Elem);
 }
 
 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 (auto Elem : DBV)
+  // CHECK-FIXES: for (unsigned int Elem : DBV)
   // CHECK-FIXES-NEXT: printf("%d\n", Elem);
 
   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 (auto Elem : DBV)
+  // CHECK-FIXES: for (unsigned int Elem : DBV)
   // CHECK-FIXES-NEXT: auto f = [DBV, &Elem]() {};
   // CHECK-FIXES-NEXT: printf("%d\n", Elem);
 }
 
+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

test/clang-tidy/modernize-loop-convert-camelback.cpp

 // RUN: %check_clang_tidy %s modernize-loop-convert %t \
 // RUN:   -config="{CheckOptions: [{key: modernize-loop-convert.NamingStyle, value: 'camelBack'}]}" \
 // RUN:   -- -std=c++11 -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 const int n = 10;
 int arr[n];
 int nums[n];
 
 void naming() {
   for (int i = 0; i < n; ++i) {
     printf("%d\n", arr[i]);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead [modernize-loop-convert]
-  // CHECK-FIXES: for (auto & elem : arr)
+  // CHECK-FIXES: for (int & elem : arr)
   // CHECK-FIXES-NEXT: printf("%d\n", elem);
 
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i]);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & num : nums)
+  // CHECK-FIXES: for (int & num : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", num);
 
   int num = 0;
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i] + num);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : nums)
+  // CHECK-FIXES: for (int & elem : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", elem + num);
 
   int elem = 0;
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i] + num + elem);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & numsI : nums)
+  // CHECK-FIXES: for (int & numsI : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", numsI + num + elem);
 
   int numsI = 0;
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i] + num + elem + numsI);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & numsElem : nums)
+  // CHECK-FIXES: for (int & numsElem : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", numsElem + num + elem + numsI);
 
   int numsElem = 0;
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i] + num + elem + numsI + numsElem);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & giveMeName0 : nums)
+  // CHECK-FIXES: for (int & giveMeName0 : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", giveMeName0 + num + elem + numsI + numsElem);
 
   int giveMeName0 = 0;
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i] + num + elem + numsI + numsElem + giveMeName0);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & giveMeName1 : nums)
+  // CHECK-FIXES: for (int & giveMeName1 : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", giveMeName1 + num + elem + numsI + numsElem + giveMeName0);
 
   int numsJ = 0;
   for (int i = 0; i < n; ++i) {
     for (int j = 0; j < n; ++j) {
       printf("%d\n", nums[i] + nums[j] + num + elem + numsI + numsJ + numsElem);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
   // CHECK-MESSAGES: :[[@LINE-5]]:5: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & giveMeName0 : nums)
-  // CHECK-FIXES: for (auto & giveMeName1 : nums)
+  // CHECK-FIXES: for (int & giveMeName0 : nums)
+  // CHECK-FIXES: for (int & giveMeName1 : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", giveMeName0 + giveMeName1 + num + elem + numsI + numsJ + numsElem);
 }

test/clang-tidy/modernize-loop-convert-extra.cpp

void aliasing() {
 
   int IntArr[N];
   for (unsigned I = 0; I < N; ++I) {
     if (int Alias = IntArr[I]) {
       sideEffect(Alias);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto Alias : IntArr)
+  // CHECK-FIXES: for (int Alias : IntArr)
   // CHECK-FIXES-NEXT: if (Alias)
 
   for (unsigned I = 0; I < N; ++I) {
     while (int Alias = IntArr[I]) {
       sideEffect(Alias);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto Alias : IntArr)
+  // CHECK-FIXES: for (int Alias : IntArr)
   // CHECK-FIXES-NEXT: while (Alias)
 
   for (unsigned I = 0; I < N; ++I) {
     switch (int Alias = IntArr[I]) {
     default:
       sideEffect(Alias);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-6]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto Alias : IntArr)
+  // CHECK-FIXES: for (int Alias : IntArr)
   // CHECK-FIXES-NEXT: switch (Alias)
 
   for (unsigned I = 0; I < N; ++I) {
     for (int Alias = IntArr[I]; Alias < N; ++Alias) {
       sideEffect(Alias);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto Alias : IntArr)
+  // CHECK-FIXES: for (int Alias : IntArr)
   // CHECK-FIXES-NEXT: for (; Alias < N; ++Alias)
 
   for (unsigned I = 0; I < N; ++I) {
     for (unsigned J = 0; int Alias = IntArr[I]; ++J) {
       sideEffect(Alias);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto Alias : IntArr)
+  // CHECK-FIXES: for (int Alias : IntArr)
   // CHECK-FIXES-NEXT: for (unsigned J = 0; Alias; ++J)
 
   struct IntRef { IntRef(const int& i); };
   for (int I = 0; I < N; ++I) {
     IntRef Int(IntArr[I]);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : IntArr)
+  // CHECK-FIXES: for (int & Elem : IntArr)
   // CHECK-FIXES-NEXT: IntRef Int(Elem);
 
   // Ensure that removing the alias doesn't leave empty lines behind.
   for (int I = 0; I < N; ++I) {
     auto &X = IntArr[I];
     X = 0;
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & X : IntArr) {
+  // CHECK-FIXES: for (int & X : IntArr) {
   // CHECK-FIXES-NEXT: {{^    X = 0;$}}
   // CHECK-FIXES-NEXT: {{^  }$}}
 }
 
 void refs_and_vals() {
   // The following tests check that the transform correctly preserves the
   // reference or value qualifiers of the aliased variable. That is, if the
   // variable was declared as a value, the loop variable will be declared as a
void refs_and_vals() {
 
   dependent<int> Dep, Other;
   for (dependent<int>::iterator It = Dep.begin(), E = Dep.end(); It != E; ++It) {
     printf("%d\n", *It);
     const int& Idx = Other[0];
     unsigned Othersize = Other.size();
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Dep)
+  // CHECK-FIXES: for (int & Elem : Dep)
   // CHECK-FIXES-NEXT: printf("%d\n", Elem);
   // CHECK-FIXES-NEXT: const int& Idx = Other[0];
   // CHECK-FIXES-NEXT: unsigned Othersize = Other.size();
 
   for (int I = 0, E = Dep.size(); I != E; ++I) {
     int Idx = Other.at(I);
   }
 }

 void sameNames() {
   int Num = 0;
   for (int I = 0; I < N; ++I) {
     printf("Fibonacci number is %d\n", Nums[I]);
     Sum += Nums[I] + 2 + Num;
     (void)Nums[I];
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Nums)
+  // CHECK-FIXES: for (int & Elem : Nums)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
   // CHECK-FIXES-NEXT: Sum += Elem + 2 + Num;
   // CHECK-FIXES-NEXT: (void)Elem;
 
   int Elem = 0;
   for (int I = 0; I < N; ++I) {
     printf("Fibonacci number is %d\n", Nums[I]);
     Sum += Nums[I] + 2 + Num + Elem;
     (void)Nums[I];
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & NumsI : Nums)
+  // CHECK-FIXES: for (int & NumsI : Nums)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", NumsI);
   // CHECK-FIXES-NEXT: Sum += NumsI + 2 + Num + Elem;
   // CHECK-FIXES-NEXT: (void)NumsI;
 }
 
 void macroConflict() {
   S MAXs;
   for (S::iterator It = MAXs.begin(), E = MAXs.end(); It != E; ++It) {
void macroConflict() {
 
   T DEFs;
   for (T::iterator It = DEFs.begin(), E = DEFs.end(); It != E; ++It) {
     if (*It == DEF) {
       printf("I found %d\n", *It);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : DEFs)
+  // CHECK-FIXES: for (int & Elem : DEFs)
   // CHECK-FIXES-NEXT: if (Elem == DEF)
   // CHECK-FIXES-NEXT: printf("I found %d\n", Elem);
 }
 
 void keywordConflict() {
   T ints;
   for (T::iterator It = ints.begin(), E = ints.end(); It != E; ++It) {
     *It = 5;
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : ints)
+  // CHECK-FIXES: for (int & Elem : ints)
   // CHECK-FIXES-NEXT: Elem = 5;
 
   U __FUNCTION__s;
   for (U::iterator It = __FUNCTION__s.begin(), E = __FUNCTION__s.end();
        It != E; ++It) {
     int __FUNCTION__s_It = (*It).X + 2;
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
   // CHECK-FIXES: for (auto & Elem : __FUNCTION__s)
   // CHECK-FIXES-NEXT: int __FUNCTION__s_It = Elem.X + 2;
 }
 
 void typeConflict() {
   T Vals;
   // Using the name "Val", although it is the name of an existing struct, is
   // safe in this loop since it will only exist within this scope.
   for (T::iterator It = Vals.begin(), E = Vals.end(); It != E; ++It)
     (void) *It;
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Val : Vals)
+  // CHECK-FIXES: for (int & Val : Vals)
 
   // We cannot use the name "Val" in this loop since there is a reference to
   // it in the body of the loop.
   for (T::iterator It = Vals.begin(), E = Vals.end(); It != E; ++It) {
     *It = sizeof(Val);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Vals)
+  // CHECK-FIXES: for (int & Elem : Vals)
   // CHECK-FIXES-NEXT: Elem = sizeof(Val);
 
   typedef struct Val TD;
   U TDs;
   // Naming the variable "TD" within this loop is safe because the typedef
   // was never used within the loop.
   for (U::iterator It = TDs.begin(), E = TDs.end(); It != E; ++It)
     (void) *It;
void typeConflict() {
   // CHECK-FIXES-NEXT: V.X = 5;
 
   using ns::St;
   T Sts;
   for (T::iterator It = Sts.begin(), E = Sts.end(); It != E; ++It) {
     *It = sizeof(St);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Sts)
+  // CHECK-FIXES: for (int & Elem : Sts)
   // CHECK-FIXES-NEXT: Elem = sizeof(St);
 }
 
 } // namespace NamingConflict
 
 namespace FreeBeginEnd {
 
 // FIXME: Loop Convert should detect free begin()/end() functions.

 
 void f() {
   /// begin()/end() - based for loops here:
   T Tt;
   for (T::iterator It = Tt.begin(); It != Tt.end(); ++It) {
     printf("I found %d\n", *It);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Tt)
+  // CHECK-FIXES: for (int & Elem : Tt)
   // CHECK-FIXES-NEXT: printf("I found %d\n", Elem);
 
   T *Pt;
   for (T::iterator It = Pt->begin(); It != Pt->end(); ++It) {
     printf("I found %d\n", *It);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : *Pt)
+  // CHECK-FIXES: for (int & Elem : *Pt)
   // CHECK-FIXES-NEXT: printf("I found %d\n", Elem);
 
   S Ss;
   for (S::iterator It = Ss.begin(); It != Ss.end(); ++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 & Elem : Ss)
void f() {
   // CHECK-FIXES-NEXT: int K = A->X + Elem.X;
 
   dependent<int> V;
   for (dependent<int>::iterator It = V.begin();
        It != V.end(); ++It) {
     printf("Fibonacci number is %d\n", *It);
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : V)
+  // CHECK-FIXES: for (int & Elem : V)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
 
   for (dependent<int>::iterator It(V.begin());
        It != V.end(); ++It) {
     printf("Fibonacci number is %d\n", *It);
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : V)
+  // CHECK-FIXES: for (int & Elem : V)
   // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
 
   doublyDependent<int, int> intmap;
   for (doublyDependent<int, int>::iterator It = intmap.begin();
        It != intmap.end(); ++It) {
     printf("intmap[%d] = %d", It->first, It->second);
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead

 const int N = 10;
 int Arr[N];
 
 void messing_with_macros() {
   for (int I = 0; I < N; ++I) {
     printf("Value: %d\n", Arr[I]);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT:  printf("Value: %d\n", Elem);
 
   for (int I = 0; I < N; ++I) {
     printf("Value: %d\n", CONT Arr[I]);
   }
 
   // Multiple macro arguments.
   for (int I = 0; I < N; ++I) {
     TWO_PARAM(Arr[I], Arr[I]);
     THREE_PARAM(Arr[I], Arr[I], Arr[I]);
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: TWO_PARAM(Elem, Elem);
   // CHECK-FIXES-NEXT: THREE_PARAM(Elem, Elem, Elem);
 }
 
 } // namespace Macros
 
 namespace Templates {
 
void capturesIndex() {
   const int N = 10;
   int Arr[N];
   // FIXME: the next four loops could be convertible, if the capture list is
   // also changed.
 
   for (int I = 0; I < N; ++I)
     auto F1 = [Arr, I]() { int R1 = Arr[I] + 1; };
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: auto F1 = [Arr, &Elem]() { int R1 = Elem + 1; };
 
   for (int I = 0; I < N; ++I)
     auto F2 = [Arr, &I]() { int R2 = Arr[I] + 3; };
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: auto F2 = [Arr, &Elem]() { int R2 = Elem + 3; };
 
   // FIXME: alias don't work if the index is captured.
   // Alias declared inside lambda (by value).
   for (int I = 0; I < N; ++I)
     auto F3 = [&Arr, I]() { int R3 = Arr[I]; };
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: auto F3 = [&Arr, &Elem]() { int R3 = Elem; };
 
 
   for (int I = 0; I < N; ++I)
     auto F4 = [&Arr, &I]() { int R4 = Arr[I]; };
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: auto F4 = [&Arr, &Elem]() { int R4 = Elem; };
 
   // Alias declared inside lambda (by reference).
   for (int I = 0; I < N; ++I)
     auto F5 = [&Arr, I]() { int &R5 = Arr[I]; };
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: auto F5 = [&Arr, &Elem]() { int &R5 = Elem; };
 
 
   for (int I = 0; I < N; ++I)
     auto F6 = [&Arr, &I]() { int &R6 = Arr[I]; };
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: auto F6 = [&Arr, &Elem]() { int &R6 = Elem; };
 
   for (int I = 0; I < N; ++I) {
     auto F = [Arr, I](int k) {
       printf("%d\n", Arr[I] + k);
     };
     F(Arr[I]);
   }
   // CHECK-MESSAGES: :[[@LINE-6]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: auto F = [Arr, &Elem](int k)
   // CHECK-FIXES-NEXT: printf("%d\n", Elem + k);
   // CHECK-FIXES: F(Elem);
 }
 
 void implicitCapture() {
   const int N = 10;
   int Arr[N];
void implicitCapture() {
   // Convertible.
   for (int I = 0; I < N; ++I) {
     auto G3 = [&]() {
       int R3 = Arr[I];
       int J3 = Arr[I] + R3;
     };
   }
   // CHECK-MESSAGES: :[[@LINE-6]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: auto G3 = [&]()
   // CHECK-FIXES-NEXT: int R3 = Elem;
   // CHECK-FIXES-NEXT: int J3 = Elem + R3;
 
   for (int I = 0; I < N; ++I) {
     auto G4 = [=]() {
       int R4 = Arr[I] + 5;
     };
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: auto G4 = [=]()
   // CHECK-FIXES-NEXT: int R4 = Elem + 5;
 
   // Alias by value.
   for (int I = 0; I < N; ++I) {
     auto G5 = [&]() {
       int R5 = Arr[I];
       int J5 = 8 + R5;
     };
   }
   // CHECK-MESSAGES: :[[@LINE-6]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto R5 : Arr)
+  // CHECK-FIXES: for (int R5 : Arr)
   // CHECK-FIXES-NEXT: auto G5 = [&]()
   // CHECK-FIXES-NEXT: int J5 = 8 + R5;
 
   // Alias by reference.
   for (int I = 0; I < N; ++I) {
     auto G6 = [&]() {
       int &R6 = Arr[I];
       int J6 = -1 + R6;
     };
   }
   // CHECK-MESSAGES: :[[@LINE-6]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & R6 : Arr)
+  // CHECK-FIXES: for (int & R6 : Arr)
   // CHECK-FIXES-NEXT: auto G6 = [&]()
   // CHECK-FIXES-NEXT: int J6 = -1 + R6;
 }
 
 void iterators() {
   dependent<int> Dep;
 
   for (dependent<int>::iterator I = Dep.begin(), E = Dep.end(); I != E; ++I)
     auto H1 = [&I]() { int R = *I; };
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Dep)
+  // CHECK-FIXES: for (int & Elem : Dep)
   // CHECK-FIXES-NEXT: auto H1 = [&Elem]() { int R = Elem; };
 
   for (dependent<int>::iterator I = Dep.begin(), E = Dep.end(); I != E; ++I)
     auto H2 = [&]() { int R = *I + 2; };
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Dep)
+  // CHECK-FIXES: for (int & Elem : Dep)
   // CHECK-FIXES-NEXT: auto H2 = [&]() { int R = Elem + 2; };
 
   // FIXME: It doesn't work with const iterators.
   for (dependent<int>::const_iterator I = Dep.begin(), E = Dep.end();
        I != E; ++I)
     auto H3 = [I]() { int R = *I; };
 
   for (dependent<int>::const_iterator I = Dep.begin(), E = Dep.end();
void captureByValue() {
   const int N = 10;
   int Arr[N];
   dependent<int> Dep;
 
   for (int I = 0; I < N; ++I) {
     auto C1 = [&Arr, I]() { if (Arr[I] == 1); };
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES: for (int & Elem : Arr)
   // CHECK-FIXES-NEXT: auto C1 = [&Arr, &Elem]() { if (Elem == 1); };
 
   for (unsigned I = 0; I < Dep.size(); ++I) {
     auto C2 = [&Dep, I]() { if (Dep[I] == 2); };
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Dep)
+  // CHECK-FIXES: for (int & Elem : Dep)
   // CHECK-FIXES-NEXT: auto C2 = [&Dep, &Elem]() { if (Elem == 2); };
 }
 
 } // namespace Lambdas
 
 namespace InitLists {
 
 struct D { int Ii; };
void f() {
   for (unsigned I = 0; I < N; ++I) {
     int A{ Array[I] };
     int B{ g(Array[I]) };
     int C{ g( { Array[I] } ) };
     D Dd{ { g( { Array[I] } ) } };
     E Ee{ { { g( { Array[I] } ) } } };
   }
   // CHECK-MESSAGES: :[[@LINE-7]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & Elem : Array)
+  // CHECK-FIXES: for (int & Elem : Array)
   // CHECK-FIXES-NEXT: int A{ Elem };
   // CHECK-FIXES-NEXT: int B{ g(Elem) };
   // CHECK-FIXES-NEXT: int C{ g( { Elem } ) };
   // CHECK-FIXES-NEXT: D Dd{ { g( { Elem } ) } };
   // CHECK-FIXES-NEXT: E Ee{ { { g( { Elem } ) } } };
 }
 
 } // namespace InitLists

test/clang-tidy/modernize-loop-convert-lowercase.cpp

 // RUN: %check_clang_tidy %s modernize-loop-convert %t \
 // RUN:   -config="{CheckOptions: [{key: modernize-loop-convert.NamingStyle, value: 'lower_case'}]}" \
 // RUN:   -- -std=c++11 -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 const int n = 10;
 int arr[n];
 int nums[n];
 int nums_[n];
 
 void naming() {
   for (int i = 0; i < n; ++i) {
     printf("%d\n", arr[i]);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead [modernize-loop-convert]
-  // CHECK-FIXES: for (auto & elem : arr)
+  // CHECK-FIXES: for (int & elem : arr)
   // CHECK-FIXES-NEXT: printf("%d\n", elem);
 
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i]);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & num : nums)
+  // CHECK-FIXES: for (int & num : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", num);
 
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums_[i]);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & num : nums_)
+  // CHECK-FIXES: for (int & num : nums_)
   // CHECK-FIXES-NEXT: printf("%d\n", num);
 
   int num = 0;
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i] + num);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : nums)
+  // CHECK-FIXES: for (int & elem : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", elem + num);
 
   int elem = 0;
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i] + num + elem);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & nums_i : nums)
+  // CHECK-FIXES: for (int & nums_i : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", nums_i + num + elem);
 
   int nums_i = 0;
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i] + num + elem + nums_i);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & nums_elem : nums)
+  // CHECK-FIXES: for (int & nums_elem : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", nums_elem + num + elem + nums_i);
 
   int nums_elem = 0;
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i] + num + elem + nums_i + nums_elem);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & give_me_name_0 : nums)
+  // CHECK-FIXES: for (int & give_me_name_0 : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", give_me_name_0 + num + elem + nums_i + nums_elem);
 
   int give_me_name_0 = 0;
   for (int i = 0; i < n; ++i) {
     printf("%d\n", nums[i] + num + elem + nums_i + nums_elem + give_me_name_0);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & give_me_name_1 : nums)
+  // CHECK-FIXES: for (int & give_me_name_1 : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", give_me_name_1 + num + elem + nums_i + nums_elem + give_me_name_0);
 
   int nums_j = 0;
   for (int i = 0; i < n; ++i) {
     for (int j = 0; j < n; ++j) {
       printf("%d\n", nums[i] + nums[j] + num + elem + nums_i + nums_j + nums_elem);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
   // CHECK-MESSAGES: :[[@LINE-5]]:5: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & give_me_name_0 : nums)
-  // CHECK-FIXES: for (auto & give_me_name_1 : nums)
+  // CHECK-FIXES: for (int & give_me_name_0 : nums)
+  // CHECK-FIXES: for (int & give_me_name_1 : nums)
   // CHECK-FIXES-NEXT: printf("%d\n", give_me_name_0 + give_me_name_1 + num + elem + nums_i + nums_j + nums_elem);
 }

test/clang-tidy/modernize-loop-convert-uppercase.cpp

 // RUN: %check_clang_tidy %s modernize-loop-convert %t \
 // RUN:   -config="{CheckOptions: [{key: modernize-loop-convert.NamingStyle, value: 'UPPER_CASE'}]}" \
 // RUN:   -- -std=c++11 -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 const int N = 10;
 int ARR[N];
 int NUMS[N];
 int NUMS_[N];
 
 void naming() {
   for (int I = 0; I < N; ++I) {
     printf("%d\n", ARR[I]);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead [modernize-loop-convert]
-  // CHECK-FIXES: for (auto & ELEM : ARR)
+  // CHECK-FIXES: for (int & ELEM : ARR)
   // CHECK-FIXES-NEXT: printf("%d\n", ELEM);
 
   for (int I = 0; I < N; ++I) {
     printf("%d\n", NUMS[I]);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & NUM : NUMS)
+  // CHECK-FIXES: for (int & NUM : NUMS)
   // CHECK-FIXES-NEXT: printf("%d\n", NUM);
 
   for (int I = 0; I < N; ++I) {
     printf("%d\n", NUMS_[I]);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & NUM : NUMS_)
+  // CHECK-FIXES: for (int & NUM : NUMS_)
   // CHECK-FIXES-NEXT: printf("%d\n", NUM);
 
   int NUM = 0;
   for (int I = 0; I < N; ++I) {
     printf("%d\n", NUMS[I] + NUM);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & ELEM : NUMS)
+  // CHECK-FIXES: for (int & ELEM : NUMS)
   // CHECK-FIXES-NEXT: printf("%d\n", ELEM + NUM);
 
   int ELEM = 0;
   for (int I = 0; I < N; ++I) {
     printf("%d\n", NUMS[I] + NUM + ELEM);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & NUMS_I : NUMS)
+  // CHECK-FIXES: for (int & NUMS_I : NUMS)
   // CHECK-FIXES-NEXT: printf("%d\n", NUMS_I + NUM + ELEM);
 
   int NUMS_I = 0;
   for (int I = 0; I < N; ++I) {
     printf("%d\n", NUMS[I] + NUM + ELEM + NUMS_I);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & NUMS_ELEM : NUMS)
+  // CHECK-FIXES: for (int & NUMS_ELEM : NUMS)
   // CHECK-FIXES-NEXT: printf("%d\n", NUMS_ELEM + NUM + ELEM + NUMS_I);
 
   int NUMS_ELEM = 0;
   for (int I = 0; I < N; ++I) {
     printf("%d\n", NUMS[I] + NUM + ELEM + NUMS_I + NUMS_ELEM);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & GIVE_ME_NAME_0 : NUMS)
+  // CHECK-FIXES: for (int & GIVE_ME_NAME_0 : NUMS)
   // CHECK-FIXES-NEXT: printf("%d\n", GIVE_ME_NAME_0 + NUM + ELEM + NUMS_I + NUMS_ELEM);
 
   int GIVE_ME_NAME_0 = 0;
   for (int I = 0; I < N; ++I) {
     printf("%d\n", NUMS[I] + NUM + ELEM + NUMS_I + NUMS_ELEM + GIVE_ME_NAME_0);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & GIVE_ME_NAME_1 : NUMS)
+  // CHECK-FIXES: for (int & GIVE_ME_NAME_1 : NUMS)
   // CHECK-FIXES-NEXT: printf("%d\n", GIVE_ME_NAME_1 + NUM + ELEM + NUMS_I + NUMS_ELEM + GIVE_ME_NAME_0);
 
   int NUMS_J = 0;
   for (int I = 0; I < N; ++I) {
     for (int J = 0; J < N; ++J) {
       printf("%d\n", NUMS[I] + NUMS[J] + NUM + ELEM + NUMS_I + NUMS_J + NUMS_ELEM);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
   // CHECK-MESSAGES: :[[@LINE-5]]:5: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & GIVE_ME_NAME_0 : NUMS)
-  // CHECK-FIXES: for (auto & GIVE_ME_NAME_1 : NUMS)
+  // CHECK-FIXES: for (int & GIVE_ME_NAME_0 : NUMS)
+  // CHECK-FIXES: for (int & GIVE_ME_NAME_1 : NUMS)
   // CHECK-FIXES-NEXT: printf("%d\n", GIVE_ME_NAME_0 + GIVE_ME_NAME_1 + NUM + ELEM + NUMS_I + NUMS_J + NUMS_ELEM);
 }