[clang][dataflow] Remove references of LatticeJoinEffect from dataflow

[li.zhe.hua]

Summary

A follow-up to D131688 to remove references to the enum within the
dataflow framework and its tests.

Depends on D131688

clang/include/clang/Analysis/FlowSensitive/MapLattice.h

 
 #ifndef LLVM_CLANG_ANALYSIS_FLOWSENSITIVE__MAPLATTICE_H
 #define LLVM_CLANG_ANALYSIS_FLOWSENSITIVE__MAPLATTICE_H
 
 #include <ostream>
 #include <string>
 #include <utility>
 
-#include "DataflowAnalysis.h"
 #include "clang/AST/Decl.h"
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace dataflow {
 
 /// A lattice that maps keys to individual lattice elements. When instantiated
 /// with an `ElementLattice` that is a bounded semi-lattice, `MapLattice` is
 /// itself a bounded semi-lattice, so long as the user limits themselves to a
 /// finite number of keys. In that case, `top` is (implicitly), the map
public:
   iterator find(const key_type &K) { return C.find(K); }
   const_iterator find(const key_type &K) const { return C.find(K); }
 
   mapped_type &operator[](const key_type &K) { return C[K]; }
 
   /// If an entry exists in one map but not the other, the missing entry is
   /// treated as implicitly mapping to `bottom`. So, the joined map contains the
   /// entry as it was in the source map.
-  LatticeJoinEffect join(const MapLattice &Other) {
-    LatticeJoinEffect Effect = LatticeJoinEffect::Unchanged;
+  void join(const MapLattice &Other) {
     for (const auto &O : Other.C) {
       auto It = C.find(O.first);
-      if (It == C.end()) {
+      if (It == C.end())
         C.insert(O);
-        Effect = LatticeJoinEffect::Changed;
-      } else if (It->second.join(O.second) == LatticeJoinEffect::Changed)
-        Effect = LatticeJoinEffect::Changed;
+      else
+        It->second.join(O.second);
     }
-    return Effect;
   }
 };
 
 /// Convenience alias that captures the common use of map lattices to model
 /// in-scope variables.
 template <typename ElementLattice>
 using VarMapLattice = MapLattice<const clang::VarDecl *, ElementLattice>;
 

clang/include/clang/Analysis/FlowSensitive/NoopLattice.h

 //===-- NoopLattice.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 the lattice with exactly one element.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_NOOP_LATTICE_H
 #define LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_NOOP_LATTICE_H
 
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
 #include <ostream>
 
 namespace clang {
 namespace dataflow {
 
 /// Trivial lattice for dataflow analysis with exactly one element.
 ///
 /// Useful for analyses that only need the Environment and nothing more.
 class NoopLattice {
 public:
   bool operator==(const NoopLattice &Other) const { return true; }
 
-  LatticeJoinEffect join(const NoopLattice &Other) {
-    return LatticeJoinEffect::Unchanged;
-  }
-};
+  void join(const NoopLattice &) {}
 
-inline std::ostream &operator<<(std::ostream &OS, const NoopLattice &) {
+  friend std::ostream &operator<<(std::ostream &OS, const NoopLattice &) {
     return OS << "noop";
   }
+};
 
 } // namespace dataflow
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_NOOP_LATTICE_H

clang/unittests/Analysis/FlowSensitive/MapLatticeTest.cpp

 #include "clang/Analysis/FlowSensitive/MapLattice.h"
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
-#include "llvm/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <ostream>
 
 using namespace clang;
 using namespace dataflow;
 
 namespace {
 // A simple lattice for basic tests.
 class BooleanLattice {
 public:
   BooleanLattice() : Value(false) {}
   explicit BooleanLattice(bool B) : Value(B) {}
 
   static BooleanLattice bottom() { return BooleanLattice(false); }
 
   static BooleanLattice top() { return BooleanLattice(true); }
 
-  LatticeJoinEffect join(BooleanLattice Other) {
-    auto Prev = Value;
-    Value = Value || Other.Value;
-    return Prev == Value ? LatticeJoinEffect::Unchanged
-                         : LatticeJoinEffect::Changed;
-  }
+  void join(BooleanLattice Other) { Value = Value || Other.Value; }
 
   friend bool operator==(BooleanLattice LHS, BooleanLattice RHS) {
     return LHS.Value == RHS.Value;
   }
 
   friend bool operator!=(BooleanLattice LHS, BooleanLattice RHS) {
     return LHS.Value != RHS.Value;
   }
TEST(MapLatticeTest, JoinChange) {
   MapLattice<int, BooleanLattice> Lattice2;
   Lattice2.insert({Key1, BooleanLattice(true)});
   Lattice2.insert({Key2, BooleanLattice(true)});
 
   ASSERT_THAT(Lattice1,
               UnorderedElementsAre(Pair(Key1, BooleanLattice(false)),
                                    Pair(Key2, BooleanLattice(false))));
 
-  ASSERT_EQ(Lattice1.join(Lattice2), LatticeJoinEffect::Changed);
+  Lattice1.join(Lattice2);
   EXPECT_THAT(Lattice1, UnorderedElementsAre(Pair(Key1, BooleanLattice(true)),
                                              Pair(Key2, BooleanLattice(true))));
 }
 
 TEST(MapLatticeTest, JoinEqNoChange) {
   MapLattice<int, BooleanLattice> Lattice;
   Lattice.insert({Key1, BooleanLattice(false)});
   Lattice.insert({Key2, BooleanLattice(false)});
 
-  ASSERT_EQ(Lattice.join(Lattice), LatticeJoinEffect::Unchanged);
+  Lattice.join(Lattice);
   EXPECT_THAT(Lattice, UnorderedElementsAre(Pair(Key1, BooleanLattice(false)),
                                             Pair(Key2, BooleanLattice(false))));
 }
 
 TEST(MapLatticeTest, JoinLtNoChange) {
   MapLattice<int, BooleanLattice> Lattice1;
   Lattice1.insert({Key1, BooleanLattice(false)});
   Lattice1.insert({Key2, BooleanLattice(false)});
 
   MapLattice<int, BooleanLattice> Lattice2;
   Lattice2.insert({Key1, BooleanLattice(true)});
   Lattice2.insert({Key2, BooleanLattice(true)});
 
   ASSERT_THAT(Lattice1,
               UnorderedElementsAre(Pair(Key1, BooleanLattice(false)),
                                    Pair(Key2, BooleanLattice(false))));
 
   ASSERT_THAT(Lattice2, UnorderedElementsAre(Pair(Key1, BooleanLattice(true)),
                                              Pair(Key2, BooleanLattice(true))));
 
-  ASSERT_EQ(Lattice2.join(Lattice1), LatticeJoinEffect::Unchanged);
+  Lattice2.join(Lattice1);
   EXPECT_THAT(Lattice2, UnorderedElementsAre(Pair(Key1, BooleanLattice(true)),
                                              Pair(Key2, BooleanLattice(true))));
 }
 
 TEST(MapLatticeTest, JoinDifferentDomainsProducesUnion) {
   MapLattice<int, BooleanLattice> Lattice1;
   Lattice1.insert({Key1, BooleanLattice(true)});
   MapLattice<int, BooleanLattice> Lattice2;
   Lattice2.insert({Key2, BooleanLattice(true)});
 
-  ASSERT_EQ(Lattice1.join(Lattice2), LatticeJoinEffect::Changed);
+  Lattice1.join(Lattice2);
   EXPECT_THAT(Lattice1, UnorderedElementsAre(Pair(Key1, BooleanLattice(true)),
                                              Pair(Key2, BooleanLattice(true))));
 }
 
 TEST(MapLatticeTest, FindWorks) {
   MapLattice<int, BooleanLattice> Lattice;
   Lattice.insert({Key1, BooleanLattice(true)});
   Lattice.insert({Key2, BooleanLattice(false)});

clang/unittests/Analysis/FlowSensitive/MatchSwitchTest.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/Stmt.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
 #include "clang/Analysis/FlowSensitive/MapLattice.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/Support/Annotations.h"

 public:
   BooleanLattice() : Value(false) {}
   explicit BooleanLattice(bool B) : Value(B) {}
 
   static BooleanLattice bottom() { return BooleanLattice(false); }
 
   static BooleanLattice top() { return BooleanLattice(true); }
 
-  LatticeJoinEffect join(BooleanLattice Other) {
-    auto Prev = Value;
-    Value = Value || Other.Value;
-    return Prev == Value ? LatticeJoinEffect::Unchanged
-                         : LatticeJoinEffect::Changed;
-  }
+  void join(BooleanLattice Other) { Value = Value || Other.Value; }
 
   friend bool operator==(BooleanLattice LHS, BooleanLattice RHS) {
     return LHS.Value == RHS.Value;
   }
 
   friend std::ostream &operator<<(std::ostream &Os, const BooleanLattice &B) {
     Os << B.Value;
     return Os;

clang/unittests/Analysis/FlowSensitive/MultiVarConstantPropagationTest.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/Stmt.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
 #include "clang/Analysis/FlowSensitive/MapLattice.h"
-#include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Testing/Support/Annotations.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
struct ValueLattice {
 
   friend bool operator==(const ValueLattice &Lhs, const ValueLattice &Rhs) {
     return Lhs.State == Rhs.State && Lhs.Value == Rhs.Value;
   }
   friend bool operator!=(const ValueLattice &Lhs, const ValueLattice &Rhs) {
     return !(Lhs == Rhs);
   }
 
-  LatticeJoinEffect join(const ValueLattice &Other) {
+  void join(const ValueLattice &Other) {
     if (*this == Other || Other == bottom() || *this == top())
-      return LatticeJoinEffect::Unchanged;
+      return;
 
     if (*this == bottom()) {
       *this = Other;
-      return LatticeJoinEffect::Changed;
+      return;
     }
 
     *this = top();
-    return LatticeJoinEffect::Changed;
   }
 };
 
 std::ostream &operator<<(std::ostream &OS, const ValueLattice &L) {
   if (L.Value)
     return OS << *L.Value;
   switch (L.State) {
   case ValueLattice::ValueState::Undefined:

clang/unittests/Analysis/FlowSensitive/SingleVarConstantPropagationTest.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/Stmt.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
-#include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Testing/Support/Annotations.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
static constexpr ConstantPropagationLattice top() {
     return {VarValue{nullptr, 0}};
   }
 
   friend bool operator==(const ConstantPropagationLattice &Lhs,
                          const ConstantPropagationLattice &Rhs) {
     return Lhs.Data == Rhs.Data;
   }
 
-  LatticeJoinEffect join(const ConstantPropagationLattice &Other) {
+  void join(const ConstantPropagationLattice &Other) {
     if (*this == Other || Other == bottom() || *this == top())
-      return LatticeJoinEffect::Unchanged;
+      return;
 
     if (*this == bottom()) {
       *this = Other;
-      return LatticeJoinEffect::Changed;
+      return;
     }
 
     *this = top();
-    return LatticeJoinEffect::Changed;
   }
 };
 
 std::ostream &operator<<(std::ostream &OS,
                          const ConstantPropagationLattice &L) {
   if (L == L.bottom())
     return OS << "None";
   if (L == L.top())

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/Type.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysisContext.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
-#include "clang/Analysis/FlowSensitive/DataflowLattice.h"
 #include "clang/Analysis/FlowSensitive/NoopAnalysis.h"
 #include "clang/Analysis/FlowSensitive/Value.h"
 #include "clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringRef.h"
auto BlockStates = llvm::cantFail(
         return NoopAnalysis(C, false);
       }));
   EXPECT_EQ(BlockStates.size(), 2u);
   EXPECT_TRUE(BlockStates[0].has_value());
   EXPECT_TRUE(BlockStates[1].has_value());
 }
 
 struct HasWidenLattice {
-  HasWidenLattice() {
-    ON_CALL(*this, join).WillByDefault([](const HasWidenLattice &) {
-      return LatticeJoinEffect::Unchanged;
-    });
-  }
+  HasWidenLattice() = default;
   // Mock objects are not copyable by default. Since this is a monostate,
   // delegate to the default ctor.
   HasWidenLattice(const HasWidenLattice &) : HasWidenLattice() {}
   HasWidenLattice &operator=(const HasWidenLattice &) { return *this; }
 
-  MOCK_METHOD(LatticeJoinEffect, join, (const HasWidenLattice &));
+  MOCK_METHOD(void, join, (const HasWidenLattice &));
   MOCK_METHOD(void, widen, (const HasWidenLattice &));
 
   friend bool operator==(const HasWidenLattice &, const HasWidenLattice &) {
     return true;
   }
 };
 
 class HasWidenAnalysis
TEST(DataflowAnalysisTest, WidenPrefersWidenWhenProvided) {
   EXPECT_CALL(LA, join).Times(0);
   EXPECT_CALL(LB, join).Times(0);
   EXPECT_CALL(LA, widen(Ref(LB))).Times(1);
 
   Analysis.widenTypeErased(A, B);
 }
 
 struct OnlyJoinLattice {
-  OnlyJoinLattice() {
-    ON_CALL(*this, join).WillByDefault([](const OnlyJoinLattice &) {
-      return LatticeJoinEffect::Unchanged;
-    });
-  }
+  OnlyJoinLattice() = default;
   // Mock objects are not copyable by default. Since this is a monostate,
   // delegate to the default ctor.
   OnlyJoinLattice(const OnlyJoinLattice &) : OnlyJoinLattice() {}
   OnlyJoinLattice &operator=(const OnlyJoinLattice &) { return *this; }
 
-  MOCK_METHOD(LatticeJoinEffect, join, (const OnlyJoinLattice &));
+  MOCK_METHOD(void, join, (const OnlyJoinLattice &));
 
   friend bool operator==(const OnlyJoinLattice &, const OnlyJoinLattice &) {
     return true;
   }
 };
 
 class OnlyJoinAnalysis
     : public DataflowAnalysis<OnlyJoinAnalysis, OnlyJoinLattice> {

 
 struct NonConvergingLattice {
   int State;
 
   bool operator==(const NonConvergingLattice &Other) const {
     return State == Other.State;
   }
 
-  LatticeJoinEffect join(const NonConvergingLattice &Other) {
-    if (Other.State == 0)
-      return LatticeJoinEffect::Unchanged;
-    State += Other.State;
-    return LatticeJoinEffect::Changed;
-  }
+  void join(const NonConvergingLattice &Other) { State += Other.State; }
 };
 
 class NonConvergingAnalysis
     : public DataflowAnalysis<NonConvergingAnalysis, NonConvergingLattice> {
 public:
   explicit NonConvergingAnalysis(ASTContext &Context)
       : DataflowAnalysis<NonConvergingAnalysis, NonConvergingLattice>(
             Context,
struct ConvergesOnWidenLattice {
   bool Top = false;
 
   bool operator==(const ConvergesOnWidenLattice &Other) const {
     if (Top)
       return Other.Top;
     return State == Other.State;
   }
 
-  LatticeJoinEffect join(const ConvergesOnWidenLattice &Other) {
-    auto Prev = *this;
+  void join(const ConvergesOnWidenLattice &Other) {
     Top = Top || Other.Top;
     State += Other.State;
-    return Prev == *this ? LatticeJoinEffect::Unchanged
-                         : LatticeJoinEffect::Changed;
   }
 
   void widen(const ConvergesOnWidenLattice &Other) { Top = true; }
 
   friend std::ostream &operator<<(std::ostream &OS,
                                   const ConvergesOnWidenLattice &L) {
     return OS << "{" << L.State << "," << (L.Top ? "true" : "false") << "}";
   }

 
 struct FunctionCallLattice {
   llvm::SmallSet<std::string, 8> CalledFunctions;
 
   bool operator==(const FunctionCallLattice &Other) const {
     return CalledFunctions == Other.CalledFunctions;
   }
 
-  LatticeJoinEffect join(const FunctionCallLattice &Other) {
-    if (Other.CalledFunctions.empty())
-      return LatticeJoinEffect::Unchanged;
-    const size_t size_before = CalledFunctions.size();
+  void join(const FunctionCallLattice &Other) {
     CalledFunctions.insert(Other.CalledFunctions.begin(),
                            Other.CalledFunctions.end());
-    return CalledFunctions.size() == size_before ? LatticeJoinEffect::Unchanged
-                                                 : LatticeJoinEffect::Changed;
   }
 };
 
 std::ostream &operator<<(std::ostream &OS, const FunctionCallLattice &L) {
   std::string S;
   llvm::raw_string_ostream ROS(S);
   llvm::interleaveComma(L.CalledFunctions, ROS);
   return OS << "{" << S << "}";