[Analyzer][solver][NFC] print constraints deterministically (ordered by their string representation)

[martong]

Summary

This change is an extension to D103967 where I added dump methods for
(dis)equality classes of the State. There, the (dis)equality classes and their
contents are dumped in an ordered fashion, they are ordered based on their
string representation. This is very useful once we start to use FileCheck to
test the State dump in certain tests.

[NoQ]

Thanks!

You got me thinking whether two symbols can have the same dump. We definitely don't want this to happen but there's also no reason to believe it doesn't, given that this wouldn't affect any actual behavior or any tests. Can we add an assert here that the symbol is always freshly added? In this case we'd at least know when that happens.

[martong]

In D106642#2900397, @NoQ wrote:

Thanks!

You got me thinking whether two symbols can have the same dump. We definitely don't want this to happen but there's also no reason to believe it doesn't, given that this wouldn't affect any actual behavior or any tests. Can we add an assert here that the symbol is always freshly added? In this case we'd at least know when that happens.

Thanks for the review! I've added an assertion to check that a symbol's dump is unique.

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

 void RangeConstraintManager::printJson(raw_ostream &Out, ProgramStateRef State,
                                        const char *NL, unsigned int Space,
                                        bool IsDot) const {
   printConstraints(Out, State, NL, Space, IsDot);
   printEquivalenceClasses(Out, State, NL, Space, IsDot);
   printDisequalities(Out, State, NL, Space, IsDot);
 }
 
+static std::string toString(const SymbolRef &Sym) {
+  std::string S;
+  llvm::raw_string_ostream O(S);
+  Sym->dumpToStream(O);
+  return O.str();
+}
+
 void RangeConstraintManager::printConstraints(raw_ostream &Out,
                                               ProgramStateRef State,
                                               const char *NL,
                                               unsigned int Space,
                                               bool IsDot) const {
   ConstraintRangeTy Constraints = State->get<ConstraintRange>();
 
   Indent(Out, Space, IsDot) << "\"constraints\": ";
   if (Constraints.isEmpty()) {
     Out << "null," << NL;
     return;
   }
 
-  ++Space;
-  Out << '[' << NL;
-  bool First = true;
+  std::map<std::string, RangeSet> OrderedConstraints;
   for (std::pair<EquivalenceClass, RangeSet> P : Constraints) {
     SymbolSet ClassMembers = P.first.getClassMembers(State);
+    for (const SymbolRef &ClassMember : ClassMembers) {
+      bool insertion_took_place;
+      std::tie(std::ignore, insertion_took_place) =
+          OrderedConstraints.insert({toString(ClassMember), P.second});
+      assert(insertion_took_place &&
+             "two symbols should not have the same dump");
+    }
+  }
 
-    // We can print the same constraint for every class member.
-    for (SymbolRef ClassMember : ClassMembers) {
-      if (First) {
-        First = false;
-      } else {
-        Out << ',';
-        Out << NL;
-      }
-      Indent(Out, Space, IsDot)
-          << "{ \"symbol\": \"" << ClassMember << "\", \"range\": \"";
-      P.second.dump(Out);
-      Out << "\" }";
-    }
-  }
+  ++Space;
+  Out << '[' << NL;
+  bool First = true;
+  for (std::pair<std::string, RangeSet> P : OrderedConstraints) {
+        << "{ \"symbol\": \"" << P.first << "\", \"range\": \"";
   Out << NL;
 
   --Space;
   Indent(Out, Space, IsDot) << "]," << NL;
 }
 
-static std::string toString(const SymbolRef &Sym) {
-  std::string S;
-  llvm::raw_string_ostream O(S);
-  Sym->dumpToStream(O);
-  return O.str();
-}
-
 static std::string toString(ProgramStateRef State, EquivalenceClass Class) {
   SymbolSet ClassMembers = Class.getClassMembers(State);
   llvm::SmallVector<SymbolRef, 8> ClassMembersSorted(ClassMembers.begin(),
                                                      ClassMembers.end());
   llvm::sort(ClassMembersSorted,
              [](const SymbolRef &LHS, const SymbolRef &RHS) {
                return toString(LHS) < toString(RHS);
              });