[analyzer][NFC] Make AnalyzerConfig round-tripping deterministic

[steakhal]

Summary

In asserted builds, we do a so-called "round-tripping". This is called
from CompilerInvocation::CreateFromArgs, which eventually calls
generateCC1CommandLine from the lambda. That, in turn, calls a bunch
of GenerateXXX functions, thus ours as well: GenerateAnalyzerArgs.
The round tripping ensures some consistency property, also that the
generator generates the arguments in a deterministic order.

This works at the moment, but as soon as we add a new AnalyzerOption to
the AnalyzerOptions.def file, it's pretty likely that it will produce
the same sequence of args BUT in a different order for the second round
of round-tripping, resulting in an err_cc1_round_trip_mismatch
diagnostic.

This happens because inside GenerateAnalyzerArgs, we iterate over the
Opts.Config, which is of type StringMap. Well, the iteration order
is not guaranteed to be deterministic for that. Quote
https://llvm.org/docs/ProgrammersManual.html#llvm-adt-stringmap-h

StringMap iteration order, however, is not guaranteed to be
deterministic, so any uses which require that should instead use a
std::map.

Consequently, to allow adding/removing analyzer options to
AnalyzerOptions.def without relying on the current iteration order, we
need to make that deterministic. And that is what I'm proposing in this
patch.

[jansvoboda11]

Has this not been addressed by D142861 already?

[steakhal]

In D154437#4471225, @jansvoboda11 wrote:

Has this not been addressed by D142861 already?

Hm, The same failure. This must be related. I'll have a look.
But, you can try it yourself that the issue still remains:
Add a new StringRef option to the AnalyzerOptions.def and it's likely it will break the clang/test/Analysis/shallow-mode.m test.

[steakhal]

Ah, D142861 is only on main, that's why we don't have that. I'll cherry-pick that then.
@jansvoboda11 Thanks for the xref!

Confirmed, that fixes the issue. Abandoning this one.

clang-tools-extra/clang-tidy/ClangTidy.cpp

 setStaticAnalyzerCheckerOpts(const ClangTidyOptions &Opts,
                              clang::AnalyzerOptions &AnalyzerOptions) {
   StringRef AnalyzerPrefix(AnalyzerCheckNamePrefix);
   for (const auto &Opt : Opts.CheckOptions) {
     StringRef OptName(Opt.getKey());
     if (!OptName.consume_front(AnalyzerPrefix))
       continue;
     // Analyzer options are always local options so we can ignore priority.
-    AnalyzerOptions.Config[OptName] = Opt.getValue().Value;
+    AnalyzerOptions.Config[OptName.str()] = Opt.getValue().Value;
   }
 }
 
 typedef std::vector<std::pair<std::string, bool>> CheckersList;
 
 static CheckersList getAnalyzerCheckersAndPackages(ClangTidyContext &Context,
                                                    bool IncludeExperimental) {
   CheckersList List;

clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

 /// whenever.
 ///
 /// Some of the options are controlled by raw frontend flags for no good reason,
 /// and should be eventually converted into -analyzer-config flags. New analyzer
 /// options should not be implemented as frontend flags. Frontend flags still
 /// make sense for things that do not affect the actual analysis.
 class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
 public:
-  using ConfigTable = llvm::StringMap<std::string>;
+  using ConfigTable = std::map<std::string, std::string>;
 
   /// Retrieves the list of checkers generated from Checkers.td. This doesn't
   /// contain statically linked but non-generated checkers and plugin checkers!
   static std::vector<StringRef>
   getRegisteredCheckers(bool IncludeExperimental = false);
 
   /// Retrieves the list of packages generated from Checkers.td. This doesn't
   /// contain statically linked but non-generated packages and plugin packages!

clang/lib/Frontend/CompilerInvocation.cpp

#include "clang/StaticAnalyzer/Core/Analyses.def"
   }
 
   AnalyzerOptions ConfigOpts;
   parseAnalyzerConfigs(ConfigOpts, nullptr);
 
   for (const auto &C : Opts.Config) {
     // Don't generate anything that came from parseAnalyzerConfigs. It would be
     // redundant and may not be valid on the command line.
-    auto Entry = ConfigOpts.Config.find(C.getKey());
-    if (Entry != ConfigOpts.Config.end() && Entry->getValue() == C.getValue())
+    auto Entry = ConfigOpts.Config.find(C.first);
+    if (Entry != ConfigOpts.Config.end() && Entry->second == C.second)
       continue;
 
-    GenerateArg(Args, OPT_analyzer_config, C.getKey() + "=" + C.getValue(), SA);
+    GenerateArg(Args, OPT_analyzer_config, C.first + "=" + C.second, SA);
   }
 
   // Nothing to generate for FullCompilerInvocation.
 }
 
 static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
                               DiagnosticsEngine &Diags) {
   unsigned NumErrorsBefore = Diags.getNumErrors();
for (const auto &configVal : configVals) {
       // Leave unknown non-checker configs unclaimed.
       if (!key.contains(":") && Opts.isUnknownAnalyzerConfig(key)) {
         if (Opts.ShouldEmitErrorsOnInvalidConfigValue)
           Diags.Report(diag::err_analyzer_config_unknown) << key;
         continue;
       }
 
       A->claim();
-      Opts.Config[key] = std::string(val);
+      Opts.Config[key.str()] = val.str();
 
       // FIXME: Remove this hunk after clang-17 released.
       constexpr auto SingleFAM =
           "consider-single-element-arrays-as-flexible-array-members";
       if (key == SingleFAM) {
         Diags.Report(diag::warn_analyzer_deprecated_option_with_alternative)
             << SingleFAM << "clang-17"
             << "-fstrict-flex-arrays=<N>";
#include "clang/StaticAnalyzer/Core/Analyses.def"
   }
   os.flush();
 
   return Diags.getNumErrors() == NumErrorsBefore;
 }
 
 static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config,
                                  StringRef OptionName, StringRef DefaultVal) {
-  return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
+  return Config.insert({OptionName.str(), DefaultVal.str()}).first->second;
 }
 
 static void initOption(AnalyzerOptions::ConfigTable &Config,
                        DiagnosticsEngine *Diags,
                        StringRef &OptionField, StringRef Name,
                        StringRef DefaultVal) {
   // String options may be known to invalid (e.g. if the expected string is a
   // file name, but the file does not exist), those will have to be checked in

clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp

 //===----------------------------------------------------------------------===//
 // ConfigDumper
 //===----------------------------------------------------------------------===//
 
 namespace {
 class ConfigDumper : public Checker< check::EndOfTranslationUnit > {
   typedef AnalyzerOptions::ConfigTable Table;
 
-  static int compareEntry(const Table::MapEntryTy *const *LHS,
-                          const Table::MapEntryTy *const *RHS) {
-    return (*LHS)->getKey().compare((*RHS)->getKey());
+  static int compareEntry(const Table::value_type *const *LHS,
+                          const Table::value_type *const *RHS) {
+    return (*LHS)->first.compare((*RHS)->first);
   }
 
 public:
   void checkEndOfTranslationUnit(const TranslationUnitDecl *TU,
                                  AnalysisManager& mgr,
                                  BugReporter &BR) const {
     const Table &Config = mgr.options.Config;
 
-    SmallVector<const Table::MapEntryTy *, 32> Keys;
+    SmallVector<const Table::value_type *, 32> Keys;
     for (Table::const_iterator I = Config.begin(), E = Config.end(); I != E;
          ++I)
       Keys.push_back(&*I);
     llvm::array_pod_sort(Keys.begin(), Keys.end(), compareEntry);
 
     llvm::errs() << "[config]\n";
     for (unsigned I = 0, E = Keys.size(); I != E; ++I)
-      llvm::errs() << Keys[I]->getKey() << " = "
+      llvm::errs() << Keys[I]->first << " = "
                    << (Keys[I]->second.empty() ? "\"\"" : Keys[I]->second)
                    << '\n';
   }
 };
 }
 
 void ento::registerConfigDumper(CheckerManager &mgr) {
   mgr.registerChecker<ConfigDumper>();

clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

assert(!CheckerName.empty() &&
          "Empty checker name! Make sure the checker object (including it's "
          "bases!) if fully initialized before calling this function!");
 
   ConfigTable::const_iterator E = Config.end();
   do {
     ConfigTable::const_iterator I =
         Config.find((Twine(CheckerName) + ":" + OptionName).str());
     if (I != E)
-      return StringRef(I->getValue());
+      return StringRef(I->second);
     size_t Pos = CheckerName.rfind('.');
     if (Pos == StringRef::npos)
       break;
 
     CheckerName = CheckerName.substr(0, Pos);
   } while (!CheckerName.empty() && SearchInParents);
 
   llvm_unreachable("Unknown checker option! Did you call getChecker*Option "

clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp

static void insertAndValidate(StringRef FullName, const CmdLineOption &Option,
   if (It.second)
     return;
 
   // Insertion failed, the user supplied this package/checker option on the
   // command line. If the supplied value is invalid, we'll restore the option
   // to it's default value, and if we're in non-compatibility mode, we'll also
   // emit an error.
 
-  StringRef SuppliedValue = It.first->getValue();
+  StringRef SuppliedValue = It.first->second;
 
   if (Option.OptionType == "bool") {
     if (SuppliedValue != "true" && SuppliedValue != "false") {
       if (AnOpts.ShouldEmitErrorsOnInvalidConfigValue) {
         Diags.Report(diag::err_analyzer_checker_option_invalid_input)
             << FullOption << "a boolean value";
       }
 
-      It.first->setValue(std::string(Option.DefaultValStr));
+      It.first->second = Option.DefaultValStr.str();
     }
     return;
   }
 
   if (Option.OptionType == "int") {
     int Tmp;
     bool HasFailed = SuppliedValue.getAsInteger(0, Tmp);
     if (HasFailed) {
       if (AnOpts.ShouldEmitErrorsOnInvalidConfigValue) {
         Diags.Report(diag::err_analyzer_checker_option_invalid_input)
             << FullOption << "an integer value";
       }
 
-      It.first->setValue(std::string(Option.DefaultValStr));
+      It.first->second = Option.DefaultValStr.str();
     }
     return;
   }
 }
 
 template <class T>
 static void insertOptionToCollection(StringRef FullName, T &Collection,
                                      const CmdLineOption &Option,

 }
 
 void CheckerRegistry::validateCheckerOptions() const {
   for (const auto &Config : AnOpts.Config) {
 
     StringRef SuppliedCheckerOrPackage;
     StringRef SuppliedOption;
     std::tie(SuppliedCheckerOrPackage, SuppliedOption) =
-        Config.getKey().split(':');
+        StringRef(Config.first).split(':');
 
     if (SuppliedOption.empty())
       continue;
 
     // AnalyzerOptions' config table contains the user input, so an entry could
     // look like this:
     //
     //   cor:NoFalsePositives=true