[clang][dataflow] Eliminate deprecated `DataflowAnalysis` constructor.

[ymandel]

Thanks!

[mboehme]

Failing pre-merge checks look unrelated

clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h

 template <typename Derived, typename LatticeT>
 class DataflowAnalysis : public TypeErasedDataflowAnalysis {
 public:
   /// Bounded join-semilattice that is used in the analysis.
   using Lattice = LatticeT;
 
   explicit DataflowAnalysis(ASTContext &Context) : Context(Context) {}
 
-  /// Deprecated. Use the `DataflowAnalysisOptions` constructor instead.
-  explicit DataflowAnalysis(ASTContext &Context, bool ApplyBuiltinTransfer)
-      : DataflowAnalysis(
-            Context,
-            {ApplyBuiltinTransfer
-                 ? DataflowAnalysisContext::Options{}
-                 : std::optional<DataflowAnalysisContext::Options>()}) {}
-
   explicit DataflowAnalysis(ASTContext &Context,
                             DataflowAnalysisOptions Options)
       : TypeErasedDataflowAnalysis(Options), Context(Context) {}
 
   ASTContext &getASTContext() final { return Context; }
 
   TypeErasedLattice typeErasedInitialElement() final {
     return {static_cast<Derived *>(this)->initialElement()};

clang/include/clang/Analysis/FlowSensitive/NoopAnalysis.h

 namespace clang {
 namespace dataflow {
 
 class NoopAnalysis : public DataflowAnalysis<NoopAnalysis, NoopLattice> {
 public:
   NoopAnalysis(ASTContext &Context)
       : DataflowAnalysis<NoopAnalysis, NoopLattice>(Context) {}
 
-  /// Deprecated. Use the `DataflowAnalysisOptions` constructor instead.
-  NoopAnalysis(ASTContext &Context, bool ApplyBuiltinTransfer)
-      : DataflowAnalysis<NoopAnalysis, NoopLattice>(Context,
-                                                    ApplyBuiltinTransfer) {}
-
-  /// `ApplyBuiltinTransfer` controls whether to run the built-in transfer
-  /// functions that model memory during the analysis. Their results are not
-  /// used by `NoopAnalysis`, but tests that need to inspect the environment
-  /// should enable them.
   NoopAnalysis(ASTContext &Context, DataflowAnalysisOptions Options)
       : DataflowAnalysis<NoopAnalysis, NoopLattice>(Context, Options) {}
 
   static NoopLattice initialElement() { return {}; }
 
   void transfer(const CFGElement &E, NoopLattice &L, Environment &Env) {}
 };
 
 } // namespace dataflow
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_NOOPANALYSIS_H

clang/unittests/Analysis/FlowSensitive/ChromiumCheckModelTest.cpp

std::string ReplacePattern(std::string S, const std::string &Pattern,
   return S;
 }
 
 template <typename Model>
 class ModelAdaptorAnalysis
     : public DataflowAnalysis<ModelAdaptorAnalysis<Model>, NoopLattice> {
 public:
   explicit ModelAdaptorAnalysis(ASTContext &Context)
-      : DataflowAnalysis<ModelAdaptorAnalysis, NoopLattice>(
-            Context, /*ApplyBuiltinTransfer=*/true) {}
+      : DataflowAnalysis<ModelAdaptorAnalysis, NoopLattice>(Context) {}
 
   static NoopLattice initialElement() { return NoopLattice(); }
 
   void transfer(const CFGElement &E, NoopLattice &, Environment &Env) {
     M.transfer(E, Env);
   }
 
 private:

clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp

std::function<
         void(const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &,
              const AnalysisOutputs &)>
         Expectations) {
   ASSERT_THAT_ERROR(checkDataflow<NoopAnalysis>(
                         AnalysisInputs<NoopAnalysis>(
                             Code, std::move(TargetFuncMatcher),
                             [](ASTContext &Context, Environment &) {
                               return NoopAnalysis(
-                                  Context, /*ApplyBuiltinTransfer=*/false);
+                                  Context,
+                                  // Don't apply builtin transfer function.
+                                  DataflowAnalysisOptions{std::nullopt});
                             })
                             .withASTBuildArgs({"-fsyntax-only", "-std=c++17"}),
                         /*VerifyResults=*/std::move(Expectations)),
                     llvm::Succeeded());
 }
 
 TEST(ProgramPointAnnotations, NoAnnotations) {
   ::testing::MockFunction<void(

clang/unittests/Analysis/FlowSensitive/TransferTest.cpp

public:
         // [[p]]
       }
     };
   )";
   ASSERT_THAT_ERROR(
       checkDataflow<NoopAnalysis>(
           AnalysisInputs<NoopAnalysis>(
               Code, cxxConstructorDecl(ofClass(hasName("B"))),
-              [](ASTContext &C, Environment &) {
-                return NoopAnalysis(C, /*ApplyBuiltinTransfer=*/true);
-              })
+              [](ASTContext &C, Environment &) { return NoopAnalysis(C); })
               .withASTBuildArgs(
                   {"-fsyntax-only", "-fno-delayed-template-parsing",
                    "-std=" + std::string(LangStandard::getLangStandardForKind(
                                              LangStandard::lang_cxx17)
                                              .getName())}),
           /*VerifyResults=*/
           [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
              const AnalysisOutputs &) {

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

runAnalysis(llvm::StringRef Code, AnalysisT (*MakeAnalysis)(ASTContext &)) {
   Environment Env(DACtx);
 
   return runDataflowAnalysis(CFCtx, Analysis, Env);
 }
 
 TEST(DataflowAnalysisTest, NoopAnalysis) {
   auto BlockStates = llvm::cantFail(
       runAnalysis<NoopAnalysis>("void target() {}", [](ASTContext &C) {
-        return NoopAnalysis(C, false);
+        return NoopAnalysis(C,
+                            // Don't use builtin transfer function.
+                            DataflowAnalysisOptions{std::nullopt});
       }));
   EXPECT_EQ(BlockStates.size(), 2u);
   EXPECT_TRUE(BlockStates[0].has_value());
   EXPECT_TRUE(BlockStates[1].has_value());
 }
 
 // Basic test that `diagnoseFunction` calls the Diagnoser function for the
 // number of elements expected.

 };
 
 class NonConvergingAnalysis
     : public DataflowAnalysis<NonConvergingAnalysis, NonConvergingLattice> {
 public:
   explicit NonConvergingAnalysis(ASTContext &Context)
       : DataflowAnalysis<NonConvergingAnalysis, NonConvergingLattice>(
             Context,
-            /*ApplyBuiltinTransfer=*/false) {}
+            // Don't apply builtin transfer function.
+            DataflowAnalysisOptions{std::nullopt}) {}
 
   static NonConvergingLattice initialElement() { return {0}; }
 
   void transfer(const CFGElement &, NonConvergingLattice &E, Environment &) {
     ++E.State;
   }
 };
 

 protected:
   template <typename Matcher>
   void runDataflow(llvm::StringRef Code, Matcher Match) {
     ASSERT_THAT_ERROR(
         checkDataflow<NoopAnalysis>(
             AnalysisInputs<NoopAnalysis>(
                 Code, ast_matchers::hasName("target"),
                 [](ASTContext &Context, Environment &Env) {
-                  return NoopAnalysis(Context, true);
+                  return NoopAnalysis(Context);
                 })
                 .withASTBuildArgs({"-fsyntax-only", "-std=c++17"}),
             /*VerifyResults=*/[&Match](const llvm::StringMap<
                                            DataflowAnalysisState<NoopLattice>>
                                            &Results,
                                        const AnalysisOutputs
                                            &AO) { Match(Results, AO.ASTCtx); }),
         llvm::Succeeded());