Reuse CachedConstAccessorsLattice for pointer nullability lattice

The functionality in the pointer nullability lattice was extracted into CachedConstAccessorsLattice for reuse in llvm/llvm-project#111006 . So it should be the same, except for some names (get$X vs getOrCreate$X), and a callback for initializing a StorageLocation if created by getOrCreate$X. Perhaps in the future more can be abstracted into the base dataflow transfer functions.

PiperOrigin-RevId: 697632107
Change-Id: Ibfcaa741b86ff85352c9abc9901034a8ac47c035

Author: Googler

bazel/llvm.bzl

@@ -53,7 +53,7 @@ def _llvm_loader_repository(repository_ctx):
             executable = False,
         )
 
-LLVM_COMMIT_SHA = "b3134fa2338388adf8cfb2d77339d0b042eab9f6"
+LLVM_COMMIT_SHA = "64c455077abe583f96fc19398712da9c1187ad61"
 
 def llvm_loader_repository_dependencies():
     # This *declares* the dependency, but it won't actually be *downloaded* unless it's used.

nullability/pointer_nullability_analysis.cc

@@ -1257,8 +1257,15 @@ void handleConstMemberCall(
   // treatment is different from booleans or raw pointers, which are
   // represented as Values.
   if (RecordLoc != nullptr && isSupportedSmartPointerType(CE->getType())) {
-    StorageLocation *Loc = State.Lattice.getConstMethodReturnStorageLocation(
-        *RecordLoc, CE, State.Env);
+    StorageLocation *Loc =
+        State.Lattice.getOrCreateConstMethodReturnStorageLocation(
+            *RecordLoc, CE, State.Env, [&](StorageLocation &Loc) {
+              setSmartPointerValue(
+                  cast<RecordStorageLocation>(Loc),
+                  cast<PointerValue>(State.Env.createValue(
+                      underlyingRawPointerType(CE->getType()))),
+                  State.Env);
+            });
     if (Loc == nullptr) return;
 
     if (CE->isGLValue()) {
@@ -1281,8 +1288,8 @@ void handleConstMemberCall(
   if (RecordLoc != nullptr && CE->isPRValue() &&
       (isSupportedRawPointerType(CE->getType()) ||
        CE->getType()->isBooleanType())) {
-    Value *Val =
-        State.Lattice.getConstMethodReturnValue(*RecordLoc, CE, State.Env);
+    Value *Val = State.Lattice.getOrCreateConstMethodReturnValue(*RecordLoc, CE,
+                                                                 State.Env);
     if (Val == nullptr) return;
 
     State.Env.setValue(*CE, *Val);

nullability/pointer_nullability_lattice.cc

@@ -10,27 +10,17 @@
 
 #include "absl/base/nullability.h"
 #include "absl/log/check.h"
-#include "nullability/pointer_nullability.h"
 #include "nullability/type_nullability.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/Expr.h"
-#include "clang/Analysis/FlowSensitive/DataflowAnalysisContext.h"
-#include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
 #include "clang/Analysis/FlowSensitive/DataflowLattice.h"
-#include "clang/Analysis/FlowSensitive/StorageLocation.h"
-#include "clang/Analysis/FlowSensitive/Value.h"
 #include "clang/Basic/LLVM.h"
-#include "llvm/ADT/DenseMap.h"
 
 namespace clang::tidy::nullability {
 namespace {
 
 using dataflow::LatticeJoinEffect;
-using dataflow::PointerValue;
-using dataflow::RecordStorageLocation;
-using dataflow::StorageLocation;
-using dataflow::Value;
 
 // Returns overridden nullability information associated with a declaration.
 // For now we only track top-level decl nullability symbolically and check for
@@ -49,43 +39,10 @@ absl::Nullable<const PointerTypeNullability *> getDeclNullability(
   return nullptr;
 }
 
-template <typename T>
-llvm::SmallDenseMap<const dataflow::RecordStorageLocation *,
-                    llvm::SmallDenseMap<const FunctionDecl *, T *>>
-joinConstMethodMap(
-    const llvm::SmallDenseMap<const dataflow::RecordStorageLocation *,
-                              llvm::SmallDenseMap<const FunctionDecl *, T *>>
-        &Map1,
-    const llvm::SmallDenseMap<const dataflow::RecordStorageLocation *,
-                              llvm::SmallDenseMap<const FunctionDecl *, T *>>
-        &Map2,
-    LatticeJoinEffect &Effect) {
-  llvm::SmallDenseMap<const dataflow::RecordStorageLocation *,
-                      llvm::SmallDenseMap<const FunctionDecl *, T *>>
-      Result;
-  for (auto &[Loc, DeclToT] : Map1) {
-    auto It = Map2.find(Loc);
-    if (It == Map2.end()) {
-      Effect = LatticeJoinEffect::Changed;
-      continue;
-    }
-    const auto &OtherDeclToT = It->second;
-    auto &JoinedDeclToT = Result[Loc];
-    for (auto [Func, Var] : DeclToT) {
-      T *OtherVar = OtherDeclToT.lookup(Func);
-      if (OtherVar == nullptr || OtherVar != Var) {
-        Effect = LatticeJoinEffect::Changed;
-        continue;
-      }
-      JoinedDeclToT.insert({Func, Var});
-    }
-  }
-  return Result;
-}
-
 }  // namespace
 
-const TypeNullability &PointerNullabilityLattice::insertExprNullabilityIfAbsent(
+const TypeNullability &
+PointerNullabilityLatticeBase::insertExprNullabilityIfAbsent(
     absl::Nonnull<const Expr *> E,
     const std::function<TypeNullability()> &GetNullability) {
   E = &dataflow::ignoreCFGOmittedNodes(*E);
@@ -100,41 +57,7 @@ const TypeNullability &PointerNullabilityLattice::insertExprNullabilityIfAbsent(
   return Iterator->second;
 }
 
-absl::Nullable<dataflow::Value *>
-PointerNullabilityLattice::getConstMethodReturnValue(
-    const dataflow::RecordStorageLocation &RecordLoc,
-    absl::Nonnull<const CallExpr *> CE, dataflow::Environment &Env) {
-  assert(CE->getType()->isPointerType() || CE->getType()->isBooleanType());
-  auto &ObjMap = ConstMethodReturnValues[&RecordLoc];
-  const FunctionDecl *DirectCallee = CE->getDirectCallee();
-  if (DirectCallee == nullptr) return nullptr;
-  auto it = ObjMap.find(DirectCallee);
-  if (it != ObjMap.end()) return it->second;
-  dataflow::Value *Val = Env.createValue(CE->getType());
-  if (Val != nullptr) ObjMap.insert({DirectCallee, Val});
-  return Val;
-}
-
-absl::Nullable<dataflow::StorageLocation *>
-PointerNullabilityLattice::getConstMethodReturnStorageLocation(
-    const dataflow::RecordStorageLocation &RecordLoc,
-    absl::Nonnull<const CallExpr *> CE, dataflow::Environment &Env) {
-  assert(isSupportedSmartPointerType(CE->getType()));
-  auto &ObjMap = ConstMethodReturnStorageLocations[&RecordLoc];
-  const FunctionDecl *DirectCallee = CE->getDirectCallee();
-  if (DirectCallee == nullptr) return nullptr;
-  auto it = ObjMap.find(DirectCallee);
-  if (it != ObjMap.end()) return it->second;
-  StorageLocation &Loc = Env.createStorageLocation(CE->getType());
-  setSmartPointerValue(cast<RecordStorageLocation>(Loc),
-                       cast<PointerValue>(Env.createValue(
-                           underlyingRawPointerType(CE->getType()))),
-                       Env);
-  ObjMap.insert({DirectCallee, &Loc});
-  return &Loc;
-}
-
-void PointerNullabilityLattice::overrideNullabilityFromDecl(
+void PointerNullabilityLatticeBase::overrideNullabilityFromDecl(
     absl::Nullable<const Decl *> D, TypeNullability &N) const {
   // For now, overrides are always for pointer values only, and override only
   // the top-level nullability.
@@ -144,22 +67,9 @@ void PointerNullabilityLattice::overrideNullabilityFromDecl(
   }
 }
 
-LatticeJoinEffect PointerNullabilityLattice::join(
-    const PointerNullabilityLattice &Other) {
-  // For simplicity, we only retain values that are identical, but not ones that
-  // are non-identical but equivalent. This is likely to be sufficient in
-  // practice, and it reduces implementation complexity considerably.
-
-  LatticeJoinEffect Effect = LatticeJoinEffect::Unchanged;
-  ConstMethodReturnValues = joinConstMethodMap<Value>(
-      ConstMethodReturnValues, Other.ConstMethodReturnValues, Effect);
-  ;
-
-  ConstMethodReturnStorageLocations = joinConstMethodMap<StorageLocation>(
-      ConstMethodReturnStorageLocations,
-      Other.ConstMethodReturnStorageLocations, Effect);
-
-  return Effect;
+LatticeJoinEffect PointerNullabilityLatticeBase::join(
+    const PointerNullabilityLatticeBase &Other) {
+  return LatticeJoinEffect::Unchanged;
 }
 
 }  // namespace clang::tidy::nullability

nullability/pointer_nullability_lattice.h

@@ -11,20 +11,15 @@
 
 #include "absl/base/nullability.h"
 #include "absl/container/flat_hash_map.h"
-#include "absl/log/check.h"
 #include "nullability/type_nullability.h"
-#include "clang/AST/DeclCXX.h"
 #include "clang/AST/Expr.h"
-#include "clang/Analysis/FlowSensitive/DataflowAnalysisContext.h"
-#include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
+#include "clang/Analysis/FlowSensitive/ASTOps.h"
+#include "clang/Analysis/FlowSensitive/CachedConstAccessorsLattice.h"
 #include "clang/Analysis/FlowSensitive/DataflowLattice.h"
-#include "clang/Analysis/FlowSensitive/StorageLocation.h"
-#include "clang/Analysis/FlowSensitive/Value.h"
-#include "clang/Basic/LLVM.h"
 #include "llvm/ADT/FunctionExtras.h"
 
 namespace clang::tidy::nullability {
-class PointerNullabilityLattice {
+class PointerNullabilityLatticeBase {
  public:
   struct NonFlowSensitiveState {
     // Nullability interpretation of types as set e.g. by per-file #pragmas.
@@ -46,7 +41,7 @@ class PointerNullabilityLattice {
         ConcreteNullabilityOverride = [](const Decl &) { return std::nullopt; };
   };
 
-  PointerNullabilityLattice(NonFlowSensitiveState &NFS) : NFS(NFS) {}
+  PointerNullabilityLatticeBase(NonFlowSensitiveState &NFS) : NFS(NFS) {}
 
   absl::Nullable<const TypeNullability *> getTypeNullability(
       absl::Nonnull<const Expr *> E) const {
@@ -62,65 +57,31 @@ class PointerNullabilityLattice {
       absl::Nonnull<const Expr *> E,
       const std::function<TypeNullability()> &GetNullability);
 
-  // Returns the `Value` associated with the `RecordStorageLocation` and
-  // `MethodDecl` of `CE`, creating one if it doesn't yet exist.
-  // The type of `CE` must be either a raw pointer or boolean.
-  absl::Nullable<dataflow::Value *> getConstMethodReturnValue(
-      const dataflow::RecordStorageLocation &RecordLoc,
-      absl::Nonnull<const CallExpr *> CE, dataflow::Environment &Env);
-
-  // Returns the `RecordStorageLocation` associated with the
-  // `RecordStorageLocation` and `MethodDecl` of `CE`, creating one if it
-  // doesn't yet exist. The type of `CE` must be a smart pointer.
-  absl::Nullable<dataflow::StorageLocation *>
-  getConstMethodReturnStorageLocation(
-      const dataflow::RecordStorageLocation &RecordLoc,
-      absl::Nonnull<const CallExpr *> CE, dataflow::Environment &Env);
-
-  void clearConstMethodReturnValues(
-      const dataflow::RecordStorageLocation &RecordLoc) {
-    ConstMethodReturnValues.erase(&RecordLoc);
-  }
-
-  void clearConstMethodReturnStorageLocations(
-      const dataflow::RecordStorageLocation &RecordLoc) {
-    ConstMethodReturnStorageLocations.erase(&RecordLoc);
-  }
-
   // If nullability for the decl D has been overridden, patch N to reflect it.
   // (N is the nullability of an access to D).
   void overrideNullabilityFromDecl(absl::Nullable<const Decl *> D,
                                    TypeNullability &N) const;
 
-  bool operator==(const PointerNullabilityLattice &Other) const { return true; }
+  bool operator==(const PointerNullabilityLatticeBase &Other) const {
+    return true;
+  }
 
-  dataflow::LatticeJoinEffect join(const PointerNullabilityLattice &Other);
+  dataflow::LatticeJoinEffect join(const PointerNullabilityLatticeBase &Other);
 
   const TypeNullabilityDefaults &defaults() const { return NFS.Defaults; }
 
  private:
   // Owned by the PointerNullabilityAnalysis object, shared by all lattice
   // elements within one analysis run.
   NonFlowSensitiveState &NFS;
-
-  // Maps a record storage location and const method to the value to return
-  // from that const method.
-  using ConstMethodReturnValuesType = llvm::SmallDenseMap<
-      const dataflow::RecordStorageLocation *,
-      llvm::SmallDenseMap<const FunctionDecl *, dataflow::Value *>>;
-  ConstMethodReturnValuesType ConstMethodReturnValues;
-
-  // Maps a record storage location and const method to the record storage
-  // location to return from that const method.
-  using ConstMethodReturnStorageLocationsType = llvm::SmallDenseMap<
-      const dataflow::RecordStorageLocation *,
-      llvm::SmallDenseMap<const FunctionDecl *, dataflow::StorageLocation *>>;
-  ConstMethodReturnStorageLocationsType ConstMethodReturnStorageLocations;
 };
 
+using PointerNullabilityLattice =
+    dataflow::CachedConstAccessorsLattice<PointerNullabilityLatticeBase>;
+
 inline std::ostream &operator<<(std::ostream &OS,
                                 const PointerNullabilityLattice &) {
-  return OS << "noop";
+  return OS << "nullability";
 }
 
 }  // namespace clang::tidy::nullability

nullability/pointer_nullability_lattice_test.cc

@@ -78,13 +78,14 @@ TEST_F(PointerNullabilityLatticeTest, ConstMethodProducesNewValueAfterJoin) {
   RecordStorageLocation Loc(SType, RecordStorageLocation::FieldToLoc(), {});
 
   PointerNullabilityLattice Lattice1(NFS);
-  Value *Val1 = Lattice1.getConstMethodReturnValue(Loc, CE, Env);
+  Value *Val1 = Lattice1.getOrCreateConstMethodReturnValue(Loc, CE, Env);
 
   PointerNullabilityLattice Lattice2(NFS);
-  Value *Val2 = Lattice2.getConstMethodReturnValue(Loc, CE, Env);
+  Value *Val2 = Lattice2.getOrCreateConstMethodReturnValue(Loc, CE, Env);
 
   EXPECT_EQ(Lattice1.join(Lattice2), LatticeJoinEffect::Changed);
-  Value *ValAfterJoin = Lattice1.getConstMethodReturnValue(Loc, CE, Env);
+  Value *ValAfterJoin =
+      Lattice1.getOrCreateConstMethodReturnValue(Loc, CE, Env);
 
   EXPECT_NE(ValAfterJoin, Val1);
   EXPECT_NE(ValAfterJoin, Val2);