[clang-include-fixer] Fix incorrect ranking because of dangling references

[danlark]

Summary

SymbolAndSignals stores SymbolInfo which stores two std::strings. Then
the values are stored in a llvm::DenseMap<llvm::StringRef, double>. When
the sorting is happening, SymbolAndSignals are swapped and thus because
of small string optimization some strings may become invalid. This
results in incorrect ranking.

This was detected when running new std::sort algorithm against llvm
toolchain. This could have been prevented with running llvm::sort and
EXPENSIVE_CHECKS. Unfortunately, no sanitizer yelled.

I don't have commit rights, [e-mail] Danila Kutenin

[bkramer]

Thanks

clang-tools-extra/clang-include-fixer/SymbolIndexManager.cpp

 //===-- SymbolIndexManager.cpp - Managing multiple SymbolIndices-*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolIndexManager.h"
 #include "find-all-symbols/SymbolInfo.h"
-#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Path.h"
 
 #define DEBUG_TYPE "clang-include-fixer"
 
 namespace clang {
 namespace include_fixer {
 
for (auto FileI = llvm::sys::path::begin(FileName),
     }
     MaxSegments = std::max(Segments, MaxSegments);
   }
   return MaxSegments;
 }
 
 static void rank(std::vector<SymbolAndSignals> &Symbols,
                  llvm::StringRef FileName) {
-  llvm::DenseMap<llvm::StringRef, double> Score;
+  llvm::StringMap<double> Score;
   for (const auto &Symbol : Symbols) {
     // Calculate a score from the similarity of the header the symbol is in
     // with the current file and the popularity of the symbol.
     double NewScore = similarityScore(FileName, Symbol.Symbol.getFilePath()) *
                       (1.0 + std::log2(1 + Symbol.Signals.Seen));
     double &S = Score[Symbol.Symbol.getFilePath()];
     S = std::max(S, NewScore);
   }
   // Sort by the gathered scores. Use file name as a tie breaker so we can
   // deduplicate.
-  std::sort(Symbols.begin(), Symbols.end(),
+  llvm::sort(Symbols.begin(), Symbols.end(),
              [&](const SymbolAndSignals &A, const SymbolAndSignals &B) {
                auto AS = Score[A.Symbol.getFilePath()];
                auto BS = Score[B.Symbol.getFilePath()];
                if (AS != BS)
                  return AS > BS;
                return A.Symbol.getFilePath() < B.Symbol.getFilePath();
              });
 }
 
 std::vector<find_all_symbols::SymbolInfo>
 SymbolIndexManager::search(llvm::StringRef Identifier,
                            bool IsNestedSearch,
                            llvm::StringRef FileName) const {
   // The identifier may be fully qualified, so split it and get all the context
   // names.