[clang][dataflow] Modify `transfer` in `DataflowModel` to take `CFGElement` as input instead of `Stmt`.

[wyt]

Summary

To keep API of transfer functions consistent.

The single use of this transfer function in ChromiumCheckModel is also updated.

[sgatev]

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

197

In DataflowAnalysis we use the name Element. Can we use the same here too?

[wyt]

Address comment.

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

runDataflowAnalysis(
   return BlockStates;
 }
 
 /// Abstract base class for dataflow "models": reusable analysis components that
 /// model a particular aspect of program semantics in the `Environment`. For
 /// example, a model may capture a type and its related functions.
 class DataflowModel : public Environment::ValueModel {
 public:
-  /// Return value indicates whether the model processed the `Stmt`.
-  virtual bool transfer(const Stmt *Stmt, Environment &Env) = 0;
+  /// Return value indicates whether the model processed the `Element`.
+  virtual bool transfer(const CFGElement *Element, Environment &Env) = 0;
 };
 
 } // namespace dataflow
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_DATAFLOWANALYSIS_H

clang/include/clang/Analysis/FlowSensitive/Models/ChromiumCheckModel.h

 namespace clang {
 namespace dataflow {
 
 /// Models the behavior of Chromium's CHECK, DCHECK, etc. macros, so that code
 /// after a call to `*CHECK` can rely on the condition being true.
 class ChromiumCheckModel : public DataflowModel {
 public:
   ChromiumCheckModel() = default;
-  bool transfer(const Stmt *Stmt, Environment &Env) override;
+  bool transfer(const CFGElement *Element, Environment &Env) override;
 
 private:
   /// Declarations for `::logging::CheckError::.*Check`, lazily initialized.
   llvm::SmallDenseSet<const CXXMethodDecl *> CheckDecls;
 };
 
 } // namespace dataflow
 } // namespace clang
 
 #endif // CLANG_ANALYSIS_FLOWSENSITIVE_MODELS_CHROMIUMCHECKMODEL_H

clang/lib/Analysis/FlowSensitive/Models/ChromiumCheckModel.cpp

if (CheckDecls.empty()) {
     for (const CXXMethodDecl *M : ParentClass->methods())
       if (M->getDeclName().isIdentifier() && M->getName().endswith("Check"))
         CheckDecls.insert(M);
   }
 
   return CheckDecls.contains(&D);
 }
 
-bool ChromiumCheckModel::transfer(const Stmt *Stmt, Environment &Env) {
+bool ChromiumCheckModel::transfer(const CFGElement *Element, Environment &Env) {
+  auto CS = Element->getAs<CFGStmt>();
+  if (!CS)
+    return false;
+  auto Stmt = CS->getStmt();
   if (const auto *Call = dyn_cast<CallExpr>(Stmt)) {
     if (const auto *M = dyn_cast<CXXMethodDecl>(Call->getDirectCallee())) {
       if (isCheckLikeMethod(CheckDecls, *M)) {
         // Mark this branch as unreachable.
         Env.addToFlowCondition(Env.getBoolLiteralValue(false));
         return true;
       }
     }
   }
   return false;
 }
 
 } // namespace dataflow
 } // namespace clang

clang/unittests/Analysis/FlowSensitive/ChromiumCheckModelTest.cpp

 public:
   explicit ModelAdaptorAnalysis(ASTContext &Context)
       : DataflowAnalysis<ModelAdaptorAnalysis, NoopLattice>(
             Context, /*ApplyBuiltinTransfer=*/true) {}
 
   static NoopLattice initialElement() { return NoopLattice(); }
 
   void transfer(const CFGElement *E, NoopLattice &, Environment &Env) {
-    if (auto S = E->getAs<CFGStmt>()) {
-      M.transfer(S->getStmt(), Env);
-    }
+    M.transfer(E, Env);
   }
 
 private:
   Model M;
 };
 
 template <typename Matcher>
 void runDataflow(llvm::StringRef Code, Matcher Match) {