[clang][dataflow] Expose stringification functions for SAT solver enums

[gribozavr]

Fix the build

clang/include/clang/Analysis/FlowSensitive/DebugSupport.h

 #include <vector>
 
 #include "clang/Analysis/FlowSensitive/Solver.h"
 #include "clang/Analysis/FlowSensitive/Value.h"
 #include "llvm/ADT/DenseMap.h"
 
 namespace clang {
 namespace dataflow {
+
+/// Returns a string representation of a boolean assignment to true or false.
+std::string debugString(Solver::Result::Assignment Assignment);
+
+/// Returns a string representation of the result status of a SAT check.
+std::string debugString(Solver::Result::Status Status);
+
 /// Returns a string representation for the boolean value `B`.
 ///
 /// Atomic booleans appearing in the boolean value `B` are assigned to labels
 /// either specified in `AtomNames` or created by default rules as B0, B1, ...
 ///
 /// Requirements:
 ///
 ///   Names assigned to atoms should not be repeated in `AtomNames`.

clang/lib/Analysis/FlowSensitive/DebugSupport.cpp

 
 namespace clang {
 namespace dataflow {
 
 using llvm::AlignStyle;
 using llvm::fmt_pad;
 using llvm::formatv;
 
+std::string debugString(Solver::Result::Assignment Assignment) {
+  switch (Assignment) {
+  case Solver::Result::Assignment::AssignedFalse:
+    return "False";
+  case Solver::Result::Assignment::AssignedTrue:
+    return "True";
+  }
+  llvm_unreachable("Booleans can only be assigned true/false");
+}
+
+std::string debugString(Solver::Result::Status Status) {
+  switch (Status) {
+  case Solver::Result::Status::Satisfiable:
+    return "Satisfiable";
+  case Solver::Result::Status::Unsatisfiable:
+    return "Unsatisfiable";
+  case Solver::Result::Status::TimedOut:
+    return "TimedOut";
+  }
+  llvm_unreachable("Unhandled SAT check result status");
+}
+
 namespace {
 
 class DebugStringGenerator {
 public:
   explicit DebugStringGenerator(
       llvm::DenseMap<const AtomicBoolValue *, std::string> AtomNamesArg)
       : Counter(0), AtomNames(std::move(AtomNamesArg)) {
 #ifndef NDEBUG

 )";
 
     std::vector<std::string> ConstraintsStrings;
     ConstraintsStrings.reserve(Constraints.size());
     for (auto &Constraint : Constraints) {
       ConstraintsStrings.push_back(debugString(*Constraint));
     }
 
-    auto StatusString = debugString(Result.getStatus());
+    auto StatusString = clang::dataflow::debugString(Result.getStatus());
     auto Solution = Result.getSolution();
     auto SolutionString = Solution ? "\n" + debugString(Solution.value()) : "";
 
     return formatv(
         Template,
         llvm::make_range(ConstraintsStrings.begin(), ConstraintsStrings.end()),
         StatusString, SolutionString);
   }
 
 private:
   /// Returns a string representation of a truth assignment to atom booleans.
   std::string debugString(
       const llvm::DenseMap<AtomicBoolValue *, Solver::Result::Assignment>
           &AtomAssignments) {
     size_t MaxNameLength = 0;
     for (auto &AtomName : AtomNames) {
       MaxNameLength = std::max(MaxNameLength, AtomName.second.size());
     }
 
     std::vector<std::string> Lines;
     for (auto &AtomAssignment : AtomAssignments) {
       auto Line = formatv("{0} = {1}",
                           fmt_align(getAtomName(AtomAssignment.first),
                                     AlignStyle::Left, MaxNameLength),
-                          debugString(AtomAssignment.second));
+                          clang::dataflow::debugString(AtomAssignment.second));
       Lines.push_back(Line);
     }
     llvm::sort(Lines.begin(), Lines.end());
 
     return formatv("{0:$[\n]}", llvm::make_range(Lines.begin(), Lines.end()));
   }
 
-  /// Returns a string representation of a boolean assignment to true or false.
-  std::string debugString(Solver::Result::Assignment Assignment) {
-    switch (Assignment) {
-    case Solver::Result::Assignment::AssignedFalse:
-      return "False";
-    case Solver::Result::Assignment::AssignedTrue:
-      return "True";
-    }
-    llvm_unreachable("Booleans can only be assigned true/false");
-  }
-
-  /// Returns a string representation of the result status of a SAT check.
-  std::string debugString(Solver::Result::Status Status) {
-    switch (Status) {
-    case Solver::Result::Status::Satisfiable:
-      return "Satisfiable";
-    case Solver::Result::Status::Unsatisfiable:
-      return "Unsatisfiable";
-    case Solver::Result::Status::TimedOut:
-      return "TimedOut";
-    }
-    llvm_unreachable("Unhandled SAT check result status");
-  }
-
   /// Returns the name assigned to `Atom`, either user-specified or created by
   /// default rules (B0, B1, ...).
   std::string getAtomName(const AtomicBoolValue *Atom) {
     auto Entry = AtomNames.try_emplace(Atom, formatv("B{0}", Counter));
     if (Entry.second) {
       Counter++;
     }
     return Entry.first->second;