[clang][dataflow] Change `transfer` API to take a reference.

[ymandel]

Summary

The provided CFGElement is never null, so a reference is a more precise type.

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

 /// Base class template for dataflow analyses built on a single lattice type.
 ///
 /// Requirements:
 ///
 ///  `Derived` must be derived from a specialization of this class template and
 ///  must provide the following public members:
 ///   * `LatticeT initialElement()` - returns a lattice element that models the
 ///     initial state of a basic block;
-///   * `void transfer(const CFGElement *, LatticeT &, Environment &)` - applies
+///   * `void transfer(const CFGElement &, LatticeT &, Environment &)` - applies
 ///     the analysis transfer function for a given CFG element and lattice
 ///     element.
 ///
 ///  `Derived` can optionally provide the following members:
 ///  * `void transferBranch(bool Branch, const Stmt *Stmt, TypeErasedLattice &E,
 ///                         Environment &Env)` - applies the analysis transfer
 ///    function for a given edge from a CFG block of a conditional statement.
 ///
bool isEqualTypeErased(const TypeErasedLattice &E1,
     const Lattice &L1 = llvm::any_cast<const Lattice &>(E1.Value);
     const Lattice &L2 = llvm::any_cast<const Lattice &>(E2.Value);
     return L1 == L2;
   }
 
   void transferTypeErased(const CFGElement &Element, TypeErasedLattice &E,
                           Environment &Env) final {
     Lattice &L = llvm::any_cast<Lattice &>(E.Value);
-    // FIXME: change the contract of `transfer` to take a reference.
-    static_cast<Derived *>(this)->transfer(&Element, L, Env);
+    static_cast<Derived *>(this)->transfer(Element, L, Env);
   }
 
   void transferBranchTypeErased(bool Branch, const Stmt *Stmt,
                                 TypeErasedLattice &E, Environment &Env) final {
     transferBranchInternal(Rank0{}, *static_cast<Derived *>(this), Branch, Stmt,
                            E, Env);
   }
 

 }
 
 /// 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 `Element`.
-  virtual bool transfer(const CFGElement *Element, Environment &Env) = 0;
+  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

 //===-- ChromiumCheckModel.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a dataflow model for Chromium's family of CHECK functions.
 //
 //===----------------------------------------------------------------------===//
 #ifndef CLANG_ANALYSIS_FLOWSENSITIVE_MODELS_CHROMIUMCHECKMODEL_H
 #define CLANG_ANALYSIS_FLOWSENSITIVE_MODELS_CHROMIUMCHECKMODEL_H
 
 #include "clang/AST/DeclCXX.h"
-#include "clang/AST/Stmt.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
 #include "llvm/ADT/DenseSet.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 CFGElement *Element, 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/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h

 public:
   UncheckedOptionalAccessModel(ASTContext &Ctx);
 
   /// Returns a matcher for the optional classes covered by this model.
   static ast_matchers::DeclarationMatcher optionalClassDecl();
 
   static NoopLattice initialElement() { return {}; }
 
-  void transfer(const CFGElement *Elt, NoopLattice &L, Environment &Env);
+  void transfer(const CFGElement &Elt, NoopLattice &L, Environment &Env);
 
   ComparisonResult compare(QualType Type, const Value &Val1,
                            const Environment &Env1, const Value &Val2,
                            const Environment &Env2) override;
 
   bool merge(QualType Type, const Value &Val1, const Environment &Env1,
              const Value &Val2, const Environment &Env2, Value &MergedVal,
              Environment &MergedEnv) override;

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

public:
   /// 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) {}
+  void transfer(const CFGElement &E, NoopLattice &L, Environment &Env) {}
 };
 
 } // namespace dataflow
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_NOOPANALYSIS_H

clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h

public:
   virtual void transferTypeErased(const CFGElement &, TypeErasedLattice &,
                                   Environment &) = 0;
 
   /// Applies the analysis transfer function for a given edge from a CFG block
   /// of a conditional statement.
   /// @param Stmt The condition which is responsible for the split in the CFG.
   /// @param Branch True if the edge goes to the basic block where the
   /// condition is true.
+  // FIXME: Change `Stmt` argument to a reference.
   virtual void transferBranchTypeErased(bool Branch, const Stmt *,
                                         TypeErasedLattice &, Environment &) = 0;
 
   /// If the built-in model is enabled, returns the options to be passed to
   /// them. Otherwise returns empty.
   const std::optional<DataflowAnalysisContext::Options> &
   builtinOptions() const {
     return Options.BuiltinOpts;

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 CFGElement *Element, Environment &Env) {
-  auto CS = Element->getAs<CFGStmt>();
+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));

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

 UncheckedOptionalAccessModel::optionalClassDecl() {
   return optionalClass();
 }
 
 UncheckedOptionalAccessModel::UncheckedOptionalAccessModel(ASTContext &Ctx)
     : DataflowAnalysis<UncheckedOptionalAccessModel, NoopLattice>(Ctx),
       TransferMatchSwitch(buildTransferMatchSwitch()) {}
 
-void UncheckedOptionalAccessModel::transfer(const CFGElement *Elt,
+void UncheckedOptionalAccessModel::transfer(const CFGElement &Elt,
                                             NoopLattice &L, Environment &Env) {
   LatticeTransferState State(L, Env);
-  TransferMatchSwitch(*Elt, getASTContext(), State);
+  TransferMatchSwitch(Elt, getASTContext(), State);
 }
 
 ComparisonResult UncheckedOptionalAccessModel::compare(
     QualType Type, const Value &Val1, const Environment &Env1,
     const Value &Val2, const Environment &Env2) {
   if (!isOptionalType(Type))
     return ComparisonResult::Unknown;
   bool MustNonEmpty1 = isNonEmptyOptional(Val1, Env1);

clang/unittests/Analysis/FlowSensitive/ChromiumCheckModelTest.cpp

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

clang/unittests/Analysis/FlowSensitive/MultiVarConstantPropagationTest.cpp

public:
   explicit ConstantPropagationAnalysis(ASTContext &Context)
       : DataflowAnalysis<ConstantPropagationAnalysis,
                          ConstantPropagationLattice>(Context) {}
 
   static ConstantPropagationLattice initialElement() {
     return ConstantPropagationLattice::bottom();
   }
 
-  void transfer(const CFGElement *E, ConstantPropagationLattice &Vars,
+  void transfer(const CFGElement &E, ConstantPropagationLattice &Vars,
                 Environment &Env) {
-    auto CS = E->getAs<CFGStmt>();
+    auto CS = E.getAs<CFGStmt>();
     if (!CS)
       return;
     auto S = CS->getStmt();
     auto matcher =
         stmt(anyOf(declStmt(hasSingleDecl(
                        varDecl(decl().bind(kVar), hasType(isInteger()),
                                optionally(hasInitializer(expr().bind(kInit))))
                            .bind(kDecl))),

clang/unittests/Analysis/FlowSensitive/SignAnalysisTest.cpp

class SignPropagationAnalysis
     : public DataflowAnalysis<SignPropagationAnalysis, NoopLattice> {
 public:
   SignPropagationAnalysis(ASTContext &Context)
       : DataflowAnalysis<SignPropagationAnalysis, NoopLattice>(Context),
         TransferMatchSwitch(buildTransferMatchSwitch()) {}
 
   static NoopLattice initialElement() { return {}; }
 
-  void transfer(const CFGElement *Elt, NoopLattice &L, Environment &Env) {
+  void transfer(const CFGElement &Elt, NoopLattice &L, Environment &Env) {
     LatticeTransferState State(L, Env);
-    TransferMatchSwitch(*Elt, getASTContext(), State);
+    TransferMatchSwitch(Elt, getASTContext(), State);
   }
   bool merge(QualType Type, const Value &Val1, const Environment &Env1,
              const Value &Val2, const Environment &Env2, Value &MergedVal,
              Environment &MergedEnv) override;
 
 private:
   CFGMatchSwitch<TransferState<NoopLattice>> TransferMatchSwitch;
 };

clang/unittests/Analysis/FlowSensitive/SingleVarConstantPropagationTest.cpp

public:
   explicit ConstantPropagationAnalysis(ASTContext &Context)
       : DataflowAnalysis<ConstantPropagationAnalysis,
                          ConstantPropagationLattice>(Context) {}
 
   static ConstantPropagationLattice initialElement() {
     return ConstantPropagationLattice::bottom();
   }
 
-  void transfer(const CFGElement *E, ConstantPropagationLattice &Element,
+  void transfer(const CFGElement &E, ConstantPropagationLattice &Element,
                 Environment &Env) {
-    auto CS = E->getAs<CFGStmt>();
+    auto CS = E.getAs<CFGStmt>();
     if (!CS)
       return;
     auto S = CS->getStmt();
     auto matcher = stmt(
         anyOf(declStmt(hasSingleDecl(varDecl(hasType(isInteger()),
                                              hasInitializer(expr().bind(kInit)))
                                          .bind(kVar))),
               binaryOperator(hasOperatorName("="), hasLHS(refToVar()),

clang/unittests/Analysis/FlowSensitive/TransferBranchTest.cpp

 };
 
 class TestPropagationAnalysis
     : public DataflowAnalysis<TestPropagationAnalysis, TestLattice> {
 public:
   explicit TestPropagationAnalysis(ASTContext &Context)
       : DataflowAnalysis<TestPropagationAnalysis, TestLattice>(Context) {}
   static TestLattice initialElement() { return TestLattice::bottom(); }
-  void transfer(const CFGElement *, TestLattice &, Environment &) {}
+  void transfer(const CFGElement &, TestLattice &, Environment &) {}
   void transferBranch(bool Branch, const Stmt *S, TestLattice &L,
                       Environment &Env) {
     L.Branch = Branch;
   }
 };
 
 using ::testing::UnorderedElementsAre;
 

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

 public:
   explicit NonConvergingAnalysis(ASTContext &Context)
       : DataflowAnalysis<NonConvergingAnalysis, NonConvergingLattice>(
             Context,
             /*ApplyBuiltinTransfer=*/false) {}
 
   static NonConvergingLattice initialElement() { return {0}; }
 
-  void transfer(const CFGElement *, NonConvergingLattice &E, Environment &) {
+  void transfer(const CFGElement &, NonConvergingLattice &E, Environment &) {
     ++E.State;
   }
 };
 
 TEST(DataflowAnalysisTest, NonConvergingAnalysis) {
   std::string Code = R"(
     void target() {
       while(true) {}

 class FunctionCallAnalysis
     : public DataflowAnalysis<FunctionCallAnalysis, FunctionCallLattice> {
 public:
   explicit FunctionCallAnalysis(ASTContext &Context)
       : DataflowAnalysis<FunctionCallAnalysis, FunctionCallLattice>(Context) {}
 
   static FunctionCallLattice initialElement() { return {}; }
 
-  void transfer(const CFGElement *Elt, FunctionCallLattice &E, Environment &) {
-    auto CS = Elt->getAs<CFGStmt>();
+  void transfer(const CFGElement &Elt, FunctionCallLattice &E, Environment &) {
+    auto CS = Elt.getAs<CFGStmt>();
     if (!CS)
       return;
     const auto *S = CS->getStmt();
     if (auto *C = dyn_cast<CallExpr>(S)) {
       if (auto *F = dyn_cast<FunctionDecl>(C->getCalleeDecl())) {
         E.CalledFunctions.insert(F->getNameInfo().getAsString());
       }
     }

 class SpecialBoolAnalysis final
     : public DataflowAnalysis<SpecialBoolAnalysis, NoopLattice> {
 public:
   explicit SpecialBoolAnalysis(ASTContext &Context)
       : DataflowAnalysis<SpecialBoolAnalysis, NoopLattice>(Context) {}
 
   static NoopLattice initialElement() { return {}; }
 
-  void transfer(const CFGElement *Elt, NoopLattice &, Environment &Env) {
-    auto CS = Elt->getAs<CFGStmt>();
+  void transfer(const CFGElement &Elt, NoopLattice &, Environment &Env) {
+    auto CS = Elt.getAs<CFGStmt>();
     if (!CS)
       return;
     const auto *S = CS->getStmt();
     auto SpecialBoolRecordDecl = recordDecl(hasName("SpecialBool"));
     auto HasSpecialBoolType = hasType(SpecialBoolRecordDecl);
 
     if (const auto *E = selectFirst<CXXConstructExpr>(
             "call", match(cxxConstructExpr(HasSpecialBoolType).bind("call"), *S,

 class OptionalIntAnalysis final
     : public DataflowAnalysis<OptionalIntAnalysis, NoopLattice> {
 public:
   explicit OptionalIntAnalysis(ASTContext &Context)
       : DataflowAnalysis<OptionalIntAnalysis, NoopLattice>(Context) {}
 
   static NoopLattice initialElement() { return {}; }
 
-  void transfer(const CFGElement *Elt, NoopLattice &, Environment &Env) {
-    auto CS = Elt->getAs<CFGStmt>();
+  void transfer(const CFGElement &Elt, NoopLattice &, Environment &Env) {
+    auto CS = Elt.getAs<CFGStmt>();
     if (!CS)
       return;
     const Stmt *S = CS->getStmt();
     auto OptionalIntRecordDecl = recordDecl(hasName("OptionalInt"));
     auto HasOptionalIntType = hasType(OptionalIntRecordDecl);
 
     SmallVector<BoundNodes, 1> Matches = match(
         stmt(anyOf(cxxConstructExpr(HasOptionalIntType).bind("construct"),

 
 class TopAnalysis final : public DataflowAnalysis<TopAnalysis, NoopLattice> {
 public:
   explicit TopAnalysis(ASTContext &Context)
       : DataflowAnalysis<TopAnalysis, NoopLattice>(Context) {}
 
   static NoopLattice initialElement() { return {}; }
 
-  void transfer(const CFGElement *Elt, NoopLattice &, Environment &Env) {
-    auto CS = Elt->getAs<CFGStmt>();
+  void transfer(const CFGElement &Elt, NoopLattice &, Environment &Env) {
+    auto CS = Elt.getAs<CFGStmt>();
     if (!CS)
       return;
     const Stmt *S = CS->getStmt();
     SmallVector<BoundNodes, 1> Matches =
         match(callExpr(callee(functionDecl(hasName("makeTop")))).bind("top"),
               *S, getASTContext());
     if (const auto *E = selectFirst<CallExpr>("top", Matches)) {
       auto &Loc = Env.createStorageLocation(*E);