[clang][dataflow] Add `AnalysisInputs::withSolverFactory()`.

[sammccall]

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

180

(lambdas in headers make me slightly leery, this looks fine though)

[mboehme]

libcxx failure looks unrelated

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

withASTBuildVirtualMappedFiles(tooling::FileContentMappings Arg) && {
     ASTBuildVirtualMappedFiles = std::move(Arg);
     return std::move(*this);
   }
   AnalysisInputs<AnalysisT> &&
   withBuiltinOptions(DataflowAnalysisContext::Options Options) && {
     BuiltinOptions = std::move(Options);
     return std::move(*this);
   }
+  AnalysisInputs<AnalysisT> &&
+  withSolverFactory(std::function<std::unique_ptr<Solver>()> Factory) && {
+    assert(Factory);
+    SolverFactory = std::move(Factory);
+    return std::move(*this);
+  }
 
   /// Required. Input code that is analyzed.
   llvm::StringRef Code;
   /// Required. All functions that match this matcher are analyzed.
   ast_matchers::internal::Matcher<FunctionDecl> TargetFuncMatcher;
   /// Required. The analysis to be run is constructed with this function that
   /// takes as argument the AST generated from the code being analyzed and the
   /// initial state from which the analysis starts with.
std::function<void(
       PostVisitCFG = nullptr;
 
   /// Optional. Options for building the AST context.
   ArrayRef<std::string> ASTBuildArgs = {};
   /// Optional. Options for building the AST context.
   tooling::FileContentMappings ASTBuildVirtualMappedFiles = {};
   /// Configuration options for the built-in model.
   DataflowAnalysisContext::Options BuiltinOptions;
+  /// SAT solver factory.
+  std::function<std::unique_ptr<Solver>()> SolverFactory = [] {
+    return std::make_unique<WatchedLiteralsSolver>();
+  };
 };
 
 /// Returns assertions based on annotations that are present after statements in
 /// `AnnotatedCode`.
 llvm::Expected<llvm::DenseMap<const Stmt *, std::string>>
 buildStatementToAnnotationMapping(const FunctionDecl *Func,
                                   llvm::Annotations AnnotatedCode);
 
if (Target == nullptr)
           llvm::errc::invalid_argument, "Could not find the target function.");
 
     // Build the control flow graph for the target function.
     auto MaybeCFCtx = ControlFlowContext::build(*Target);
     if (!MaybeCFCtx) return MaybeCFCtx.takeError();
     auto &CFCtx = *MaybeCFCtx;
 
     // Initialize states for running dataflow analysis.
-    DataflowAnalysisContext DACtx(std::make_unique<WatchedLiteralsSolver>(),
+    DataflowAnalysisContext DACtx(AI.SolverFactory(),
                                   {/*Opts=*/AI.BuiltinOptions});
     Environment InitEnv(DACtx, *Target);
     auto Analysis = AI.MakeAnalysis(Context, InitEnv);
 
     AnalysisOutputs AO{AnnotatedCode, Context, Target, CFCtx,
                        Analysis,      InitEnv, {}};
 
     // Additional test setup.