[mlir][dataflow] Remove the unused AnalysisState::defaultInitialize().

[phisiart]

Summary

Depends On D131660

defaultInitialize() was introduced for the "nudging" behavior, which has been deleted.

[Mogball]

thanks! I forgot to push this change at some point

mlir/include/mlir/Analysis/DataFlow/DeadCodeAnalysis.h

 /// program point (either a block or a control-flow edge) is live.
 class Executable : public AnalysisState {
 public:
   using AnalysisState::AnalysisState;
 
   /// The state is initialized by default.
   bool isUninitialized() const override { return false; }
 
-  /// The state is always initialized.
-  ChangeResult defaultInitialize() override { return ChangeResult::NoChange; }
-
   /// Set the state of the program point to live.
   ChangeResult setToLive();
 
   /// Get whether the program point is live.
   bool isLive() const { return live; }
 
   /// Print the liveness.
   void print(raw_ostream &os) const override;

 /// control-flow predecessors can be known.
 class PredecessorState : public AnalysisState {
 public:
   using AnalysisState::AnalysisState;
 
   /// The state is initialized by default.
   bool isUninitialized() const override { return false; }
 
-  /// The state is always initialized.
-  ChangeResult defaultInitialize() override { return ChangeResult::NoChange; }
-
   /// Print the known predecessors.
   void print(raw_ostream &os) const override;
 
   /// Returns true if all predecessors are known.
   bool allPredecessorsKnown() const { return allKnown; }
 
   /// Indicate that there are potentially unknown predecessors.
   ChangeResult setHasUnknownPredecessors() {

mlir/include/mlir/Analysis/DataFlow/SparseAnalysis.h

ValueT &getValue() {
     return *optimisticValue;
   }
   const ValueT &getValue() const {
     return const_cast<Lattice<ValueT> *>(this)->getValue();
   }
 
   /// Returns true if the value of this lattice hasn't yet been initialized.
   bool isUninitialized() const override { return !optimisticValue.has_value(); }
-  /// Force the initialization of the element by setting it to its pessimistic
-  /// fixpoint.
-  ChangeResult defaultInitialize() override {
-    return markPessimisticFixpoint();
-  }
 
   /// Join the information contained in the 'rhs' lattice into this
   /// lattice. Returns if the state of the current lattice changed.
   ChangeResult join(const AbstractSparseLattice &rhs) override {
     const Lattice<ValueT> &rhsLattice =
         static_cast<const Lattice<ValueT> &>(rhs);
 
     // If rhs is uninitialized, there is nothing to do.

mlir/include/mlir/Analysis/DataFlowFramework.h

public:
   virtual ~AnalysisState();
 
   /// Create the analysis state at the given program point.
   AnalysisState(ProgramPoint point) : point(point) {}
 
   /// Returns true if the analysis state is uninitialized.
   virtual bool isUninitialized() const = 0;
 
-  /// Force an uninitialized analysis state to initialize itself with a default
-  /// value.
-  virtual ChangeResult defaultInitialize() = 0;
-
   /// Print the contents of the analysis state.
   virtual void print(raw_ostream &os) const = 0;
 
 protected:
   /// This function is called by the solver when the analysis state is updated
   /// to optionally enqueue more work items. For example, if a state tracks
   /// dependents through the IR (e.g. use-def chains), this function can be
   /// implemented to push those dependents on the worklist.

mlir/test/lib/Analysis/DataFlow/TestDenseDataFlowAnalysis.cpp

 public:
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LastModification)
 
   using AbstractDenseLattice::AbstractDenseLattice;
 
   /// The lattice is always initialized.
   bool isUninitialized() const override { return false; }
 
-  /// Initialize the lattice. Does nothing.
-  ChangeResult defaultInitialize() override { return ChangeResult::NoChange; }
-
   /// Mark the lattice as having reached its pessimistic fixpoint. That is, the
   /// last modifications of all memory resources are unknown.
   ChangeResult reset() override {
     if (lastMods.empty())
       return ChangeResult::NoChange;
     lastMods.clear();
     return ChangeResult::Change;
   }

mlir/test/lib/Analysis/TestDataFlowFramework.cpp

 namespace {
 /// This analysis state represents an integer that is XOR'd with other states.
 class FooState : public AnalysisState {
 public:
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FooState)
 
   using AnalysisState::AnalysisState;
 
-  /// Default-initialize the state to zero.
-  ChangeResult defaultInitialize() override { return join(0); }
-
   /// Returns true if the state is uninitialized.
   bool isUninitialized() const override { return !state; }
 
   /// Print the integer value or "none" if uninitialized.
   void print(raw_ostream &os) const override {
     if (state)
       os << *state;
     else