[clang][dataflow] Remove unnecessary `ASTContext` parameter from `ControlFlowContext::build` overload.

[mboehme]

Summary

When introducing this new overload in https://reviews.llvm.org/D151183, I didn't consider that the ASTContext parameter was unnecessary because it could also be obtained from the FunctionDecl.

clang/include/clang/Analysis/FlowSensitive/ControlFlowContext.h

 namespace dataflow {
 
 /// Holds CFG and other derived context that is needed to perform dataflow
 /// analysis.
 class ControlFlowContext {
 public:
   /// Builds a ControlFlowContext from a `FunctionDecl`.
   /// `Func.hasBody()` must be true, and `Func.isTemplated()` must be false.
-  static llvm::Expected<ControlFlowContext> build(const FunctionDecl &Func,
-                                                  ASTContext &C);
+  static llvm::Expected<ControlFlowContext> build(const FunctionDecl &Func);
 
   /// Builds a ControlFlowContext from an AST node. `D` is the function in which
   /// `S` resides. `D.isTemplated()` must be false.
   static llvm::Expected<ControlFlowContext> build(const Decl &D, Stmt &S,
                                                   ASTContext &C);
 
   /// Builds a ControlFlowContext from an AST node. `D` is the function in which
   /// `S` resides. `D` must not be null and `D->isTemplated()` must be false.

clang/lib/Analysis/FlowSensitive/ControlFlowContext.cpp

for (const CFGBlock *Succ : Block->succs())
       if (Succ)
         BlocksToVisit.push_back(Succ);
   }
 
   return BlockReachable;
 }
 
 llvm::Expected<ControlFlowContext>
-ControlFlowContext::build(const FunctionDecl &Func, ASTContext &C) {
+ControlFlowContext::build(const FunctionDecl &Func) {
   if (!Func.hasBody())
     return llvm::createStringError(
         std::make_error_code(std::errc::invalid_argument),
         "Cannot analyze function without a body");
 
-  return build(Func, *Func.getBody(), C);
+  return build(Func, *Func.getBody(), Func.getASTContext());
 }
 
 llvm::Expected<ControlFlowContext>
 ControlFlowContext::build(const Decl &D, Stmt &S, ASTContext &C) {
   if (D.isTemplated())
     return llvm::createStringError(
         std::make_error_code(std::errc::invalid_argument),
         "Cannot analyze templated declarations");

clang/lib/Analysis/FlowSensitive/DataflowAnalysisContext.cpp

DataflowAnalysisContext::getControlFlowContext(const FunctionDecl *F) {
   F = F->getDefinition();
   if (F == nullptr)
     return nullptr;
   auto It = FunctionContexts.find(F);
   if (It != FunctionContexts.end())
     return &It->second;
 
   if (F->hasBody()) {
-    auto CFCtx = ControlFlowContext::build(*F, F->getASTContext());
+    auto CFCtx = ControlFlowContext::build(*F);
     // FIXME: Handle errors.
     assert(CFCtx);
     auto Result = FunctionContexts.insert({F, std::move(*CFCtx)});
     return &Result.first->second;
   }
 
   return nullptr;
 }

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

for (const ast_matchers::BoundNodes &BN :
                            Context)) {
     // Get the AST node of the target function.
     const FunctionDecl *Target = BN.getNodeAs<FunctionDecl>("target");
     if (Target == nullptr)
       return llvm::make_error<llvm::StringError>(
           llvm::errc::invalid_argument, "Could not find the target function.");
 
     // Build the control flow graph for the target function.
-    auto MaybeCFCtx = ControlFlowContext::build(*Target, Context);
+    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>(),
                                   {/*Opts=*/AI.BuiltinOptions});
     Environment InitEnv(DACtx, *Target);
     auto Analysis = AI.MakeAnalysis(Context, InitEnv);

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

std::unique_ptr<ASTUnit> AST =
       tooling::buildASTFromCodeWithArgs(Code, {"-std=c++11"});
 
   auto *Func = selectFirst<FunctionDecl>(
       "func", match(functionDecl(ast_matchers::hasName("target")).bind("func"),
                     AST->getASTContext()));
   assert(Func != nullptr);
 
   auto CFCtx =
-      llvm::cantFail(ControlFlowContext::build(*Func, AST->getASTContext()));
+      llvm::cantFail(ControlFlowContext::build(*Func));
 
   AnalysisT Analysis = MakeAnalysis(AST->getASTContext());
   DataflowAnalysisContext DACtx(std::make_unique<WatchedLiteralsSolver>());
   Environment Env(DACtx);
 
   return runDataflowAnalysis(CFCtx, Analysis, Env);
 }