Add NamingStyle option to modernize-loop-convert.

[angelgarcia]

Summary

Add an option to specify wich style must be followed when choosing the new index name.

[angelgarcia]

Remove related FIXME.

[alexfh]

clang-tidy/modernize/LoopConvertUtils.cpp

815

This can be a StringRef to avoid some copies.

820

Once ContainerName is a StringRef, this can be replaced with

if (ContainerName.endswith("s"))

828

The underscore here is not needed in the LLVM style.

832

This should also handle LLVM style.

836

What will that be? <container>_elem_elem? Doesn't make sense to me.

840

The option with the trailing underscore doesn't make sense to me as well (unless we add a support for a style requiring trailing underscores for variable names).

844

I'd go with give_me_name{0,1,2,...} or something else that would make it more obvious that the automatic name selection failed and a user input is needed.

clang-tidy/modernize/LoopConvertUtils.h

418

The IdentifierNamingCheck defines styles in a more generic way (CamelCase, camelBack, lower_case, UPPER_CASE). It seems reasonable to use a similar set of options. Maybe even move the enum from that check to a common place together with the conversion routines.

418

Please add tests for all naming conventions.

448

Please make it const and put it right after Context.

[angelgarcia]

Use CamelCase on the existing tests and add a test for every other naming convention.

[alexfh]

A few minor comments.

clang-tidy/modernize/LoopConvertCheck.h

68

The variable can be const, the one above as well.

clang-tidy/modernize/LoopConvertUtils.cpp

821

No need to check the length. endswith handles this itself.

830

Automatic captures always look suspicious and require more attention. I'd avoid them unless there's a significant improvement in readability. I'd also prefer a more generic function, say AppendSuffixWithStyle, which could then be placed next to the styles enumeration and other functions to work with banking styles.

clang-tidy/modernize/LoopConvertUtils.h

447

nit: please remove the empty line.

[angelgarcia]

No need to check the length. endswith handles this itself.

I am checking that it is strictly greater than one, because we don't want an empty identifier after removing the "s".

[alexfh]

Looks good with a comment. Thank you!

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

48 ↗

(On Diff #35608)

Please add a test for GIVE_ME_NAME_{0,1}. Same for other styles.

[angelgarcia]

Done!

[alexfh]

Still looks good.

[angelgarcia]

Add nesting naming tests.

[angelgarcia]

Merge.

clang-tidy/modernize/LoopConvertCheck.h

void determineRangeDescriptor(ASTContext *Context,
                                 const UsageResult &Usages,
                                 RangeDescriptor &Descriptor);
 
   bool isConvertible(ASTContext *Context, const ast_matchers::BoundNodes &Nodes,
                      const ForStmt *Loop, LoopFixerKind FixerKind);
 
   std::unique_ptr<TUTrackingInfo> TUInfo;
   Confidence::Level MinConfidence;
+  VariableNamer::NamingStyle NamingStyle;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_LOOP_CONVERT_H

clang-tidy/modernize/LoopConvertCheck.cpp

: ContainerNeedsDereference(false), DerefByConstRef(false),
       DerefByValue(false), IsTriviallyCopyable(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)) {}
+                        .Default(Confidence::CL_Reasonable)),
+      NamingStyle(Options.get("NamingStyle", "llvm") == "llvm"
+                      ? VariableNamer::NS_LLVM
+                      : VariableNamer::NS_Google) {}
 
 void LoopConvertCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   SmallVector<std::string, 3> Confs{"risky", "reasonable", "safe"};
   Options.store(Opts, "MinConfidence", Confs[static_cast<int>(MinConfidence)]);
+  Options.store(Opts, "NamingStyle",
+                NamingStyle == VariableNamer::NS_LLVM ? "llvm" : "google");
 }
 
 void LoopConvertCheck::registerMatchers(MatchFinder *Finder) {
   // Only register the matchers for C++. Because this checker is used for
   // modernization, it is reasonable to run it on any C++ standard with the
   // assumption the user is trying to modernize their codebase.
   if (!getLangOpts().CPlusPlus)
     return;
if (VarNameFromAlias) {
 
     Diag << FixItHint::CreateReplacement(
         CharSourceRange::getTokenRange(ReplaceRange), ReplacementText);
     // No further replacements are made to the loop, since the iterator or index
     // was used exactly once - in the initialization of AliasVar.
   } else {
     VariableNamer Namer(&TUInfo->getGeneratedDecls(),
                         &TUInfo->getParentFinder().getStmtToParentStmtMap(),
-                        Loop, IndexVar, MaybeContainer, Context);
+                        Loop, IndexVar, MaybeContainer, Context, NamingStyle);
     VarName = Namer.createIndexName();
     // First, replace all usages of the array subscript expression with our new
     // variable.
     for (const auto &Usage : Usages) {
       std::string ReplaceText;
       if (Usage.Expression) {
         // If this is an access to a member through the arrow operator, after
         // the replacement it must be accessed through the '.' operator.

clang-tidy/modernize/LoopConvertUtils.h

 /// \brief Create names for generated variables within a particular statement.
 ///
 /// VariableNamer uses a DeclContext as a reference point, checking for any
 /// conflicting declarations higher up in the context or within SourceStmt.
 /// It creates a variable name using hints from a source container and the old
 /// index, if they exist.
 class VariableNamer {
 public:
+  // Supported naming styles.
+  enum NamingStyle { NS_LLVM = 0, NS_Google = 1 };
+
   VariableNamer(StmtGeneratedVarNameMap *GeneratedDecls,
                 const StmtParentMap *ReverseAST, const clang::Stmt *SourceStmt,
                 const clang::VarDecl *OldIndex,
                 const clang::VarDecl *TheContainer,
-                const clang::ASTContext *Context)
+                const clang::ASTContext *Context, NamingStyle Style)
       : GeneratedDecls(GeneratedDecls), ReverseAST(ReverseAST),
         SourceStmt(SourceStmt), OldIndex(OldIndex), TheContainer(TheContainer),
-        Context(Context) {}
+        Context(Context), Style(Style) {}
 
   /// \brief Generate a new index name.
   ///
   /// Generates the name to be used for an inserted iterator. It relies on
   /// declarationExists() to determine that there are no naming conflicts, and
   /// tries to use some hints from the container name and the old index name.
   std::string createIndexName();
 
 private:
   StmtGeneratedVarNameMap *GeneratedDecls;
   const StmtParentMap *ReverseAST;
   const clang::Stmt *SourceStmt;
   const clang::VarDecl *OldIndex;
   const clang::VarDecl *TheContainer;
   const clang::ASTContext *Context;
 
   // Determine whether or not a declaration that would conflict with Symbol
   // exists in an outer context or in any statement contained in SourceStmt.
   bool declarationExists(llvm::StringRef Symbol);
+
+  NamingStyle Style;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_LOOP_CONVERT_UTILS_H

clang-tidy/modernize/LoopConvertUtils.cpp

bool ForLoopIndexUseVisitor::TraverseStmt(Stmt *S) {
   NextStmtParent = S;
   bool Result = VisitorBase::TraverseStmt(S);
   NextStmtParent = OldNextParent;
   return Result;
 }
 
 std::string VariableNamer::createIndexName() {
   // FIXME: Add in naming conventions to handle:
-  //  - Uppercase/lowercase indices.
   //  - How to handle conflicts.
   //  - An interactive process for naming.
   std::string IteratorName;
   std::string ContainerName;
   if (TheContainer)
     ContainerName = TheContainer->getName().str();
 
   size_t Len = ContainerName.length();
   if (Len > 1 && ContainerName[Len - 1] == 's')
     IteratorName = ContainerName.substr(0, Len - 1);
   else
-    IteratorName = "elem";
+    IteratorName = (Style == NS_LLVM ? "Elem" : "elem");
 
   if (!declarationExists(IteratorName))
     return IteratorName;
 
   IteratorName = ContainerName + "_" + OldIndex->getName().str();
   if (!declarationExists(IteratorName))
     return IteratorName;
 
   IteratorName = ContainerName + "_elem";
   if (!declarationExists(IteratorName))
     return IteratorName;
 
   IteratorName += "_elem";
   if (!declarationExists(IteratorName))
     return IteratorName;
 
-  IteratorName = "_elem_";
+  IteratorName = (Style == NS_LLVM ? "Elem_" : "elem_");
 
   // Someone defeated my naming scheme...
   while (declarationExists(IteratorName))
     IteratorName += "i";
   return IteratorName;
 }
 
 /// \brief Determines whether or not the the name \a Symbol conflicts with
 /// language keywords or defined macros. Also checks if the name exists in
 /// LoopContext, any of its parent contexts, or any of its child statements.
 ///
 /// We also check to see if the same identifier was generated by this loop

clang-tidy/modernize/ModernizeTidyModule.cpp

void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<UseNullptrCheck>("modernize-use-nullptr");
     CheckFactories.registerCheck<UseOverrideCheck>("modernize-use-override");
   }
 
   ClangTidyOptions getModuleOptions() override {
     ClangTidyOptions Options;
     auto &Opts = Options.CheckOptions;
     Opts["modernize-loop-convert.MinConfidence"] = "reasonable";
+    Opts["modernize-loop-convert.NamingStyle"] = "llvm"; // Also: "google".
     Opts["modernize-pass-by-value.IncludeStyle"] = "llvm"; // Also: "google".
     Opts["modernize-replace-auto-ptr.IncludeStyle"] = "llvm"; // Also: "google".
 
     // Comma-separated list of macros that behave like NULL.
     Opts["modernize-use-nullptr.NullMacros"] = "NULL";
     return Options;
   }
 };

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-NEXT: sum += elem;
+  // CHECK-FIXES: for (auto & 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-NEXT: printf("Fibonacci number is %d\n", elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (auto & 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-NEXT: int x = elem;
-  // CHECK-FIXES-NEXT: int y = elem + 2;
+  // CHECK-FIXES: for (auto & 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 (auto & Elem : arr)
   // CHECK-FIXES-NEXT: int x = N;
-  // CHECK-FIXES-NEXT: x = elem;
+  // 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-NEXT: elem += 1;
+  // CHECK-FIXES: for (auto & 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-NEXT: int x = elem + 2;
-  // CHECK-FIXES-NEXT: elem++;
+  // CHECK-FIXES: for (auto & 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-NEXT: elem = 4 + elem;
+  // CHECK-FIXES: for (auto & 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-NEXT: sum += elem;
+  // CHECK-FIXES: for (auto & 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-NEXT: printf("Fibonacci number %d has address %p\n", elem, &elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (auto & 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();
 }
 
 void 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 (const auto & elem : constArr)
-  // CHECK-FIXES-NEXT: printf("2 * %d = %d\n", elem, elem + elem);
+  // CHECK-FIXES: for (const auto & Elem : constArr)
+  // CHECK-FIXES-NEXT: printf("2 * %d = %d\n", Elem, Elem + 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-NEXT: printf("%d", elem);
+    // CHECK-FIXES: for (auto & 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);
+    // 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-NEXT: printf("%d", elem);
+    // CHECK-FIXES: for (auto & 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);
+    // CHECK-FIXES: for (auto & Elem : this->ValArr)
+    // CHECK-FIXES-NEXT: printf("%d", Elem.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 & elem : mfpArr)
-  // CHECK-FIXES-NEXT: (v.*elem)();
+  // CHECK-FIXES: for (auto & Elem : mfpArr)
+  // CHECK-FIXES-NEXT: (v.*Elem)();
 
   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 & elem : foo)
-  // CHECK-FIXES-NEXT: int r = (v.*(elem.f))();
+  // CHECK-FIXES: for (auto & Elem : foo)
+  // CHECK-FIXES-NEXT: int r = (v.*(Elem.f))();
 
 }
 
 } // namespace Array
 
 namespace Iterator {
 
 void f() {
   /// begin()/end() - based for loops here:
   T t;
   for (T::iterator it = t.begin(), e = t.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 : t)
-  // CHECK-FIXES-NEXT: printf("I found %d\n", elem);
+  // CHECK-FIXES: for (auto & Elem : t)
+  // 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-NEXT: printf("I found %d\n", elem);
+  // CHECK-FIXES: for (auto & Elem : *pt)
+  // CHECK-FIXES-NEXT: printf("I found %d\n", Elem);
 
   S s;
   for (S::iterator it = s.begin(), e = s.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 : s)
-  // CHECK-FIXES-NEXT: printf("s has value %d\n", (elem).x);
+  // CHECK-FIXES: for (auto & Elem : s)
+  // CHECK-FIXES-NEXT: printf("s has value %d\n", (Elem).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::iterator it = s.begin(), e = s.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 : s)
-  // CHECK-FIXES-NEXT: printf("s has value %d\n", elem.x);
+  // CHECK-FIXES: for (auto & Elem : s)
+  // CHECK-FIXES-NEXT: printf("s has value %d\n", Elem.x);
 
   for (S::iterator it = s.begin(), e = s.end(); it != e; ++it) {
     it->x = 3;
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : s)
-  // CHECK-FIXES-NEXT: elem.x = 3;
+  // CHECK-FIXES: for (auto & Elem : s)
+  // CHECK-FIXES-NEXT: Elem.x = 3;
 
   for (S::iterator it = s.begin(), e = s.end(); it != e; ++it) {
     (*it).x = 3;
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : s)
-  // CHECK-FIXES-NEXT: (elem).x = 3;
+  // CHECK-FIXES: for (auto & Elem : s)
+  // CHECK-FIXES-NEXT: (Elem).x = 3;
 
   for (S::iterator it = s.begin(), e = s.end(); it != e; ++it) {
     it->nonConstFun(4, 5);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : s)
-  // CHECK-FIXES-NEXT: elem.nonConstFun(4, 5);
+  // CHECK-FIXES: for (auto & Elem : s)
+  // CHECK-FIXES-NEXT: Elem.nonConstFun(4, 5);
 
   U u;
   for (U::iterator it = u.begin(), e = u.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 : u)
-  // CHECK-FIXES-NEXT: printf("s has value %d\n", elem.x);
+  // CHECK-FIXES: for (auto & Elem : u)
+  // CHECK-FIXES-NEXT: printf("s has value %d\n", Elem.x);
 
   for (U::iterator it = u.begin(), e = u.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 : u)
-  // CHECK-FIXES-NEXT: printf("s has value %d\n", (elem).x);
+  // CHECK-FIXES: for (auto & Elem : u)
+  // CHECK-FIXES-NEXT: printf("s has value %d\n", (Elem).x);
 
   U::iterator A;
   for (U::iterator i = u.begin(), e = u.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 & elem : u)
-  // CHECK-FIXES-NEXT: int k = A->x + elem.x;
+  // CHECK-FIXES: for (auto & Elem : u)
+  // 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-NEXT: printf("Fibonacci number is %d\n", elem);
+  // CHECK-FIXES: for (auto & 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-NEXT: printf("Fibonacci number is %d\n", elem);
+  // CHECK-FIXES: for (auto & 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
-  // CHECK-FIXES: for (auto & elem : intmap)
-  // CHECK-FIXES: printf("intmap[%d] = %d", elem.first, elem.second);
+  // CHECK-FIXES: for (auto & Elem : intmap)
+  // CHECK-FIXES: printf("intmap[%d] = %d", Elem.first, Elem.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;

 void different_type() {
   // s.begin() returns a type 'iterator' which is just a non-const pointer and
   // differs from const_iterator only on the const qualification.
   S s;
   for (S::const_iterator it = s.begin(), e = s.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 (const auto & elem : s)
-  // CHECK-FIXES-NEXT: printf("s has value %d\n", (elem).x);
+  // CHECK-FIXES: for (const auto & Elem : s)
+  // CHECK-FIXES-NEXT: printf("s has value %d\n", (Elem).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 (const auto & p : *ps)
   // CHECK-FIXES-NEXT: printf("s has value %d\n", (p).x);
public:
 
   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 & elem : *this)
+    // CHECK-FIXES: for (auto & Elem : *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 & elem : *this)
+    // CHECK-FIXES: for (auto & Elem : *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 & elem : *this)
+    // CHECK-FIXES: for (auto & Elem : *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 (const auto & elem : *this)
+    // CHECK-FIXES: for (const auto & Elem : *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 (const auto & elem : *this)
+    // CHECK-FIXES: for (const auto & Elem : *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 & elem : *this)
+    // CHECK-FIXES: for (auto & Elem : *this)
   }
 };
 
 } // namespace Iterator
 
 namespace PseudoArray {
 
 const int N = 6;
 dependent<int> v;
 dependent<int> *pv;
 const dependent<int> constv;
 const dependent<int> *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 (auto & elem : v)
-  // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (auto & 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-NEXT: printf("Fibonacci number is %d\n", elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (auto & 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-NEXT: printf("Fibonacci number is %d\n", elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (auto & 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-NEXT: printf("Fibonacci number is %d\n", elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (auto & 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-NEXT: printf("Fibonacci number is %d\n", elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (auto & Elem : *cv)
+  // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
+  // CHECK-FIXES-NEXT: sum += Elem + 2;
 }
 
 void constness() {
   int sum = 0;
   for (int i = 0, e = constv.size(); i < e; ++i) {
     printf("Fibonacci number is %d\n", constv[i]);
     sum += constv[i] + 2;
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (const auto & elem : constv)
-  // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (const auto & Elem : constv)
+  // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
+  // CHECK-FIXES-NEXT: sum += Elem + 2;
 
   for (int i = 0, e = constv.size(); i < e; ++i) {
     printf("Fibonacci number is %d\n", constv.at(i));
     sum += constv.at(i) + 2;
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (const auto & elem : constv)
-  // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (const auto & Elem : constv)
+  // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
+  // CHECK-FIXES-NEXT: sum += Elem + 2;
 
   for (int i = 0, e = pconstv->size(); i < e; ++i) {
     printf("Fibonacci number is %d\n", pconstv->at(i));
     sum += pconstv->at(i) + 2;
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (const auto & elem : *pconstv)
-  // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (const auto & Elem : *pconstv)
+  // 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 < pconstv->size(); ++i) {
     printf("Fibonacci number is %d\n", (*pconstv).at(i));
     sum += (*pconstv)[i] + 2;
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (const auto & elem : *pconstv)
-  // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", elem);
-  // CHECK-FIXES-NEXT: sum += elem + 2;
+  // CHECK-FIXES: for (const auto & Elem : *pconstv)
+  // CHECK-FIXES-NEXT: printf("Fibonacci number is %d\n", Elem);
+  // CHECK-FIXES-NEXT: sum += Elem + 2;
 }
 
 // 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)
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-NEXT: printf("%d\n", elem);
+  // CHECK-FIXES: for (auto & 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 (const auto & elem : const_CBE)
-  // CHECK-FIXES-NEXT: printf("%d\n", elem);
+  // CHECK-FIXES: for (const auto & 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-NEXT: printf("%d\n", elem);
+  // CHECK-FIXES: for (auto 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-NEXT: auto f = [DBV, &elem]() {};
-  // CHECK-FIXES-NEXT: printf("%d\n", elem);
+  // CHECK-FIXES: for (auto Elem : DBV)
+  // CHECK-FIXES-NEXT: auto f = [DBV, &Elem]() {};
+  // CHECK-FIXES-NEXT: printf("%d\n", Elem);
 }
 
 } // namespace PseudoArray

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

 // RUN: %python %S/check_clang_tidy.py %s modernize-loop-convert %t -- -std=c++11 -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 namespace Dependency {
 
 void f() {
   const int N = 6;
   const int M = 8;
   int arr[N][M];
 
   for (int i = 0; i < N; ++i) {
     int a = 0;
     int b = arr[i][a];
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : arr)
+  // CHECK-FIXES: for (auto & Elem : arr)
   // CHECK-FIXES-NEXT: int a = 0;
-  // CHECK-FIXES-NEXT: int b = elem[a];
+  // CHECK-FIXES-NEXT: int b = Elem[a];
 
   for (int j = 0; j < M; ++j) {
     int a = 0;
     int b = arr[a][j];
   }
 }
 
 } // namespace Dependency
void aliasing() {
   // The container was not only used to initialize a temporary loop variable for
   // the container's elements, so we do not alias the new loop variable.
   for (int i = 0; i < N; ++i) {
     Val &t = Arr[i];
     int y = t.x;
     int z = Arr[i].x + t.x;
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : Arr)
-  // CHECK-FIXES-NEXT: Val &t = elem;
+  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES-NEXT: Val &t = Elem;
   // CHECK-FIXES-NEXT: int y = t.x;
-  // CHECK-FIXES-NEXT: int z = elem.x + t.x;
+  // CHECK-FIXES-NEXT: int z = Elem.x + t.x;
 
   for (int i = 0; i < N; ++i) {
     Val t = Arr[i];
     int y = t.x;
     int z = Arr[i].x + t.x;
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : Arr)
-  // CHECK-FIXES-NEXT: Val t = elem;
+  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES-NEXT: Val t = Elem;
   // CHECK-FIXES-NEXT: int y = t.x;
-  // CHECK-FIXES-NEXT: int z = elem.x + t.x;
+  // CHECK-FIXES-NEXT: int z = Elem.x + t.x;
 
   // The same for pseudo-arrays like std::vector<T> (or here dependent<Val>)
   // which provide a subscript operator[].
   for (int i = 0; i < v.size(); ++i) {
     Val &t = v[i];
     {}
     int y = t.x;
   }
void aliasing() {
   // CHECK-FIXES: {}
   // CHECK-FIXES-NEXT: int y = t.x;
 
   for (int i = 0; i < N; ++i) {
     Val &t = func(Arr[i]);
     int y = t.x;
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : Arr)
-  // CHECK-FIXES-NEXT: Val &t = func(elem);
+  // CHECK-FIXES: for (auto & Elem : Arr)
+  // CHECK-FIXES-NEXT: Val &t = func(Elem);
   // CHECK-FIXES-NEXT: int y = t.x;
 
   int IntArr[N];
   for (unsigned i = 0; i < N; ++i) {
     if (int alias = IntArr[i]) {
       sideEffect(alias);
     }
   }
void aliasing() {
   // CHECK-FIXES: for (auto 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-NEXT: IntRef Int(elem);
+  // CHECK-FIXES: for (auto & Elem : IntArr)
+  // CHECK-FIXES-NEXT: IntRef Int(Elem);
 }
 
 
 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
   // value and vice versa for references.
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-NEXT: printf("%d\n", elem);
+  // CHECK-FIXES: for (auto & 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);
   }
 }
 
for (int j = 0; j < N; ++j) {
       int k = Arr[i].x + Arr[j].x;
       // The repeat is there to allow FileCheck to make sure the two variable
       // names aren't the same.
       int l = Arr[i].x + Arr[j].x;
     }
   }
   // CHECK-MESSAGES: :[[@LINE-8]]:3: warning: use range-based for loop instead
   // CHECK-MESSAGES: :[[@LINE-8]]:5: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : Arr)
+  // CHECK-FIXES: for (auto & Elem : Arr)
   // CHECK-FIXES-NEXT: for (auto & Arr_j : Arr)
-  // CHECK-FIXES-NEXT: int k = elem.x + Arr_j.x;
-  // CHECK-FIXES-NOT: int l = elem.x + elem.x;
+  // CHECK-FIXES-NEXT: int k = Elem.x + Arr_j.x;
+  // CHECK-FIXES-NOT: int l = Elem.x + Elem.x;
 
   // The inner loop is also convertible, but doesn't need to be converted
   // immediately. FIXME: update this test when that changes.
   Val Nest[N][M];
   for (int i = 0; i < N; ++i) {
     for (int j = 0; j < M; ++j) {
       printf("Got item %d", Nest[i][j].x);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : Nest)
+  // CHECK-FIXES: for (auto & Elem : Nest)
   // CHECK-FIXES-NEXT: for (int j = 0; j < M; ++j)
-  // CHECK-FIXES-NEXT: printf("Got item %d", elem[j].x);
+  // CHECK-FIXES-NEXT: printf("Got item %d", Elem[j].x);
 
   // Note that the order of M and N are switched for this test.
   for (int j = 0; j < M; ++j) {
     for (int i = 0; i < N; ++i) {
       printf("Got item %d", Nest[i][j].x);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:5: warning: use range-based for loop instead
   // CHECK-FIXES-NOT: for (auto & {{[a-zA-Z_]+}} : Nest[i])
   // CHECK-FIXES: for (int j = 0; j < M; ++j)
-  // CHECK-FIXES-NEXT: for (auto & elem : Nest)
-  // CHECK-FIXES-NEXT: printf("Got item %d", elem[j].x);
+  // CHECK-FIXES-NEXT: for (auto & Elem : Nest)
+  // CHECK-FIXES-NEXT: printf("Got item %d", Elem[j].x);
 
   // The inner loop is also convertible.
   Nested<T> NestT;
   for (Nested<T>::iterator I = NestT.begin(), E = NestT.end(); I != E; ++I) {
     for (T::iterator TI = (*I).begin(), TE = (*I).end(); TI != TE; ++TI) {
       printf("%d", *TI);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : NestT)
-  // CHECK-FIXES-NEXT: for (T::iterator TI = (elem).begin(), TE = (elem).end(); TI != TE; ++TI)
+  // CHECK-FIXES: for (auto & Elem : NestT)
+  // CHECK-FIXES-NEXT: for (T::iterator TI = (Elem).begin(), TE = (Elem).end(); TI != TE; ++TI)
   // CHECK-FIXES-NEXT: printf("%d", *TI);
 
   // The inner loop is also convertible.
   Nested<S> NestS;
   for (Nested<S>::const_iterator I = NestS.begin(), E = NestS.end(); I != E; ++I) {
     for (S::const_iterator SI = (*I).begin(), SE = (*I).end(); SI != SE; ++SI) {
       printf("%d", *SI);
     }
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (const auto & elem : NestS)
-  // CHECK-FIXES-NEXT: for (S::const_iterator SI = (elem).begin(), SE = (elem).end(); SI != SE; ++SI)
+  // CHECK-FIXES: for (const auto & Elem : NestS)
+  // CHECK-FIXES-NEXT: for (S::const_iterator SI = (Elem).begin(), SE = (Elem).end(); SI != SE; ++SI)
   // CHECK-FIXES-NEXT: printf("%d", *SI);
 
   for (Nested<S>::const_iterator I = NestS.begin(), E = NestS.end(); I != E; ++I) {
     const S &s = *I;
     for (S::const_iterator SI = s.begin(), SE = s.end(); SI != SE; ++SI) {
       printf("%d", *SI);
       const_g(SI);
     }
void complexContainer() {
   X exes[5];
   int index = 0;
 
   for (S::iterator i = exes[index].getS().begin(), e = exes[index].getS().end(); i != e; ++i) {
     MutableVal k = *i;
     MutableVal j = *i;
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : exes[index].getS())
-  // CHECK-FIXES-NEXT: MutableVal k = elem;
-  // CHECK-FIXES-NEXT: MutableVal j = elem;
+  // CHECK-FIXES: for (auto & Elem : exes[index].getS())
+  // CHECK-FIXES-NEXT: MutableVal k = Elem;
+  // CHECK-FIXES-NEXT: MutableVal j = Elem;
 }
 
 void f() {
   /// begin()/end() - based for loops here:
   T t;
   for (T::iterator it = t.begin(); it != t.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 : t)
-  // CHECK-FIXES-NEXT: printf("I found %d\n", elem);
+  // CHECK-FIXES: for (auto & Elem : t)
+  // 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-NEXT: printf("I found %d\n", elem);
+  // CHECK-FIXES: for (auto & Elem : *pt)
+  // CHECK-FIXES-NEXT: printf("I found %d\n", Elem);
 
   S s;
   for (S::iterator it = s.begin(); it != s.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 : s)
-  // CHECK-FIXES-NEXT: printf("s has value %d\n", (elem).x);
+  // CHECK-FIXES: for (auto & Elem : s)
+  // CHECK-FIXES-NEXT: printf("s has value %d\n", (Elem).x);
 
   S *ps;
   for (S::iterator it = ps->begin(); it != ps->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 & p : *ps)
   // CHECK-FIXES-NEXT: printf("s has value %d\n", (p).x);
 
   for (S::iterator it = s.begin(); it != s.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 : s)
-  // CHECK-FIXES-NEXT: printf("s has value %d\n", elem.x);
+  // CHECK-FIXES: for (auto & Elem : s)
+  // CHECK-FIXES-NEXT: printf("s has value %d\n", Elem.x);
 
   for (S::iterator it = s.begin(); it != s.end(); ++it) {
     it->x = 3;
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : s)
-  // CHECK-FIXES-NEXT: elem.x = 3;
+  // CHECK-FIXES: for (auto & Elem : s)
+  // CHECK-FIXES-NEXT: Elem.x = 3;
 
   for (S::iterator it = s.begin(); it != s.end(); ++it) {
     (*it).x = 3;
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : s)
-  // CHECK-FIXES-NEXT: (elem).x = 3;
+  // CHECK-FIXES: for (auto & Elem : s)
+  // CHECK-FIXES-NEXT: (Elem).x = 3;
 
   for (S::iterator it = s.begin(); it != s.end(); ++it) {
     it->nonConstFun(4, 5);
   }
   // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : s)
-  // CHECK-FIXES-NEXT: elem.nonConstFun(4, 5);
+  // CHECK-FIXES: for (auto & Elem : s)
+  // CHECK-FIXES-NEXT: Elem.nonConstFun(4, 5);
 
   U u;
   for (U::iterator it = u.begin(); it != u.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 : u)
-  // CHECK-FIXES-NEXT: printf("s has value %d\n", elem.x);
+  // CHECK-FIXES: for (auto & Elem : u)
+  // CHECK-FIXES-NEXT: printf("s has value %d\n", Elem.x);
 
   for (U::iterator it = u.begin(); it != u.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 : u)
-  // CHECK-FIXES-NEXT: printf("s has value %d\n", (elem).x);
+  // CHECK-FIXES: for (auto & Elem : u)
+  // CHECK-FIXES-NEXT: printf("s has value %d\n", (Elem).x);
 
   U::iterator A;
   for (U::iterator i = u.begin(); i != u.end(); ++i)
     int k = A->x + i->x;
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : u)
-  // CHECK-FIXES-NEXT: int k = A->x + elem.x;
+  // CHECK-FIXES: for (auto & Elem : u)
+  // 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-NEXT: printf("Fibonacci number is %d\n", elem);
+  // CHECK-FIXES: for (auto & 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-NEXT: printf("Fibonacci number is %d\n", elem);
+  // CHECK-FIXES: for (auto & 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
-  // CHECK-FIXES: for (auto & elem : intmap)
-  // CHECK-FIXES-NEXT: printf("intmap[%d] = %d", elem.first, elem.second);
+  // CHECK-FIXES: for (auto & Elem : intmap)
+  // CHECK-FIXES-NEXT: printf("intmap[%d] = %d", Elem.first, Elem.second);
 }
 
 void different_type() {
   // 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.
 
   // s.begin() returns a type 'iterator' which is just a non-const pointer and
   // differs from const_iterator only on the const qualification.
   S s;
   for (S::const_iterator it = s.begin(); it != s.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 (const auto & elem : s)
-  // CHECK-FIXES-NEXT: printf("s has value %d\n", (elem).x);
+  // CHECK-FIXES: for (const auto & Elem : s)
+  // CHECK-FIXES-NEXT: printf("s has value %d\n", (Elem).x);
 
   S *ps;
   for (S::const_iterator it = ps->begin(); it != ps->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 (const auto & p : *ps)
   // CHECK-FIXES-NEXT: printf("s has value %d\n", (p).x);

 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-NEXT:  printf("Value: %d\n", elem);
+  // CHECK-FIXES: for (auto & 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-NEXT: TWO_PARAM(elem, elem);
-  // CHECK-FIXES-NEXT: THREE_PARAM(elem, elem, elem);
+  // CHECK-FIXES: for (auto & Elem : arr)
+  // CHECK-FIXES-NEXT: TWO_PARAM(Elem, Elem);
+  // CHECK-FIXES-NEXT: THREE_PARAM(Elem, Elem, Elem);
 }
 
 } // namespace Macros
 
 namespace Templates {
 
 template <class Container>
 void set_union(Container &container) {
   for (typename Container::const_iterator SI = container.begin(),
        SE = container.end(); SI != SE; ++SI) {
     (void) *SI;
   }
 
   S s;
   for (S::iterator SI = s.begin(), SE = s.end(); SI != SE; ++SI)
     (void) *SI;
   // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: for (auto & elem : s)
+  // CHECK-FIXES: for (auto & Elem : s)
 }
 
 void template_instantiation() {
   S a;
   set_union(a);
 }
 
 } // namespace Templates
 
 namespace Lambdas {
 
 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-NEXT: auto F1 = [Arr, &elem]() { int R1 = elem + 1; };
+  // CHECK-FIXES: for (auto & 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-NEXT: auto F2 = [Arr, &elem]() { int R2 = elem + 3; };
+  // CHECK-FIXES: for (auto & 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-NEXT: auto F3 = [&Arr, &elem]() { int R3 = elem; };
+  // CHECK-FIXES: for (auto & 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-NEXT: auto F4 = [&Arr, &elem]() { int R4 = elem; };
+  // CHECK-FIXES: for (auto & 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-NEXT: auto F5 = [&Arr, &elem]() { int &R5 = elem; };
+  // CHECK-FIXES: for (auto & 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-NEXT: auto F6 = [&Arr, &elem]() { int &R6 = elem; };
+  // CHECK-FIXES: for (auto & 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-NEXT: auto F = [Arr, &elem](int k)
-  // CHECK-FIXES-NEXT: printf("%d\n", elem + k);
-  // CHECK-FIXES: F(elem);
+  // CHECK-FIXES: for (auto & 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];
   // Index is used, not convertible.
   for (int I = 0; I < N; ++I) {
     auto G1 = [&]() {
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 (auto & Elem : Arr)
   // CHECK-FIXES-NEXT: auto G3 = [&]()
-  // CHECK-FIXES-NEXT: int R3 = elem;
-  // CHECK-FIXES-NEXT: int J3 = elem + R3;
+  // 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 (auto & Elem : Arr)
   // CHECK-FIXES-NEXT: auto G4 = [=]()
-  // CHECK-FIXES-NEXT: int R4 = elem + 5;
+  // 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;
     };
   }

 }
 
 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-NEXT: auto H1 = [&elem]() { int R = elem; };
+  // CHECK-FIXES: for (auto & 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-NEXT: auto H2 = [&]() { int R = elem + 2; };
+  // CHECK-FIXES: for (auto & 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();
        I != E; ++I)
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-NEXT: auto C1 = [&Arr, &elem]() { if (elem == 1); };
+  // CHECK-FIXES: for (auto & 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-NEXT: auto C2 = [&Dep, &elem]() { if (elem == 2); };
+  // CHECK-FIXES: for (auto & Elem : Dep)
+  // CHECK-FIXES-NEXT: auto C2 = [&Dep, &Elem]() { if (Elem == 2); };
 }
 
 } // namespace Lambdas
 
 namespace InitLists {
 
 struct D { int i; };
 struct E { D d; };
 int g(int b);
 
 void f() {
   const unsigned N = 3;
   int Array[N];
 
   // Subtrees of InitListExpr are visited twice. Test that we do not do repeated
   // replacements.
   for (unsigned i = 0; i < N; ++i) {
     int a{ Array[i] };
     int b{ g(Array[i]) };
     int c{ g( { Array[i] } ) };
     D d{ { g( { Array[i] } ) } };
     E e{ { { g( { Array[i] } ) } } };
   }
   // CHECK-MESSAGES: :[[@LINE-7]]:3: warning: use range-based for loop instead
-  // CHECK-FIXES: int a{ elem };
-  // CHECK-FIXES-NEXT: int b{ g(elem) };
-  // CHECK-FIXES-NEXT: int c{ g( { elem } ) };
-  // CHECK-FIXES-NEXT: D d{ { g( { elem } ) } };
-  // CHECK-FIXES-NEXT: E e{ { { g( { elem } ) } } };
+  // CHECK-FIXES: int a{ Elem };
+  // CHECK-FIXES-NEXT: int b{ g(Elem) };
+  // CHECK-FIXES-NEXT: int c{ g( { Elem } ) };
+  // CHECK-FIXES-NEXT: D d{ { g( { Elem } ) } };
+  // CHECK-FIXES-NEXT: E e{ { { g( { Elem } ) } } };
 }
 
 } // namespace InitLists