Avoid naming conflicts with the old index in modernize-loop-convert.

[angelgarcia]

Summary

The old index declaration is going to be removed anyway, so we can reuse its name if it is the best candidate for the new index.

[klimek]

lg

clang-tidy/modernize/LoopConvertUtils.cpp

std::string VariableNamer::createIndexName() {
   StringRef ContainerName;
   if (TheContainer)
     ContainerName = TheContainer->getName();
 
   size_t Len = ContainerName.size();
   if (Len > 1 && ContainerName.endswith(Style == NS_UpperCase ? "S" : "s")) {
     IteratorName = ContainerName.substr(0, Len - 1);
     // E.g.: (auto thing : things)
-    if (!declarationExists(IteratorName))
+    if (!declarationExists(IteratorName) || IteratorName == OldIndex->getName())
       return IteratorName;
   }
 
   if (Len > 2 && ContainerName.endswith(Style == NS_UpperCase ? "S_" : "s_")) {
     IteratorName = ContainerName.substr(0, Len - 2);
     // E.g.: (auto thing : things_)
-    if (!declarationExists(IteratorName))
+    if (!declarationExists(IteratorName) || IteratorName == OldIndex->getName())
       return IteratorName;
   }
 
   std::string Elem;
   switch (Style) {
   case NS_CamelBack:
   case NS_LowerCase:
     Elem = "elem";
     break;
   case NS_CamelCase:
     Elem = "Elem";
     break;
   case NS_UpperCase:
     Elem = "ELEM";
   }
   // E.g.: (auto elem : container)
   if (!declarationExists(Elem))
     return Elem;
 
   IteratorName = AppendWithStyle(ContainerName, OldIndex->getName());
   // E.g.: (auto container_i : container)
-  if (!declarationExists(IteratorName))
+  if (!declarationExists(IteratorName) || IteratorName == OldIndex->getName())
     return IteratorName;
 
   IteratorName = AppendWithStyle(ContainerName, Elem);
   // E.g.: (auto container_elem : container)
-  if (!declarationExists(IteratorName))
+  if (!declarationExists(IteratorName) || IteratorName == OldIndex->getName())
     return IteratorName;
 
   // Someone defeated my naming scheme...
   std::string GiveMeName;
   switch (Style) {
   case NS_CamelBack:
     GiveMeName = "giveMeName";
     break;
   case NS_CamelCase:
     GiveMeName = "GiveMeName";
     break;
   case NS_LowerCase:
     GiveMeName = "give_me_name_";
     break;
   case NS_UpperCase:
     GiveMeName = "GIVE_ME_NAME_";
   }
   int Attempt = 0;
   do {
     IteratorName = GiveMeName + std::to_string(Attempt++);
-  } while (declarationExists(IteratorName));
+  } while (declarationExists(IteratorName) ||
+           IteratorName == OldIndex->getName());
 
   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.
 ///

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

void sameNames() {
   }
   // CHECK-MESSAGES: :[[@LINE-5]]:3: warning: use range-based for loop instead
   // 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 oldIndexConflict() {
+  for (int Num = 0; Num < N; ++Num) {
+    printf("Num: %d\n", Nums[Num]);
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
+  // CHECK-FIXES: for (int Num : Nums)
+  // CHECK-FIXES-NEXT: printf("Num: %d\n", Num);
+
+  S Things;
+  for (S::iterator Thing = Things.begin(), End = Things.end(); Thing != End; ++Thing) {
+    printf("Thing: %d %d\n", Thing->X, (*Thing).X);
+  }
+  // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use range-based for loop instead
+  // CHECK-FIXES: for (auto & Thing : Things)
+  // CHECK-FIXES-NEXT: printf("Thing: %d %d\n", Thing.X, Thing.X);
+}
+
 void macroConflict() {
   S MAXs;
   for (S::iterator It = MAXs.begin(), E = MAXs.end(); It != E; ++It) {
     printf("s has value %d\n", (*It).X);
     printf("Max of 3 and 5: %d\n", MAX(3, 5));
   }
   // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: use range-based for loop instead
   // CHECK-FIXES: for (auto & Elem : MAXs)