[MLIR] Mark dominance methods const

[bondhugula]

Summary

This change is in line with MLIR's coding style
https://mlir.llvm.org/getting_started/DeveloperGuide/
and also consistent with the dominance methods in LLVM.

mlir/include/mlir/Analysis/Dominance.h

public:
 
   /// Return the dominance node from the Region containing block A.
   DominanceInfoNode *getNode(Block *a);
 
 protected:
   using super = DominanceInfoBase<IsPostDom>;
 
   /// Return true if the specified block A properly dominates block B.
-  bool properlyDominates(Block *a, Block *b);
+  bool properlyDominates(Block *a, Block *b) const;
 
   /// A mapping of regions to their base dominator tree.
   DenseMap<Region *, std::unique_ptr<base>> dominanceInfos;
 };
 } // end namespace detail
 
 /// A class for computing basic dominance information.
 class DominanceInfo : public detail::DominanceInfoBase</*IsPostDom=*/false> {
 public:
   using super::super;
 
   /// Return true if operation A properly dominates operation B.
-  bool properlyDominates(Operation *a, Operation *b);
+  bool properlyDominates(Operation *a, Operation *b) const;
 
   /// Return true if operation A dominates operation B.
-  bool dominates(Operation *a, Operation *b) {
+  bool dominates(Operation *a, Operation *b) const {
     return a == b || properlyDominates(a, b);
   }
 
   /// Return true if value A properly dominates operation B.
-  bool properlyDominates(Value a, Operation *b);
+  bool properlyDominates(Value a, Operation *b) const;
 
   /// Return true if operation A dominates operation B.
-  bool dominates(Value a, Operation *b) {
+  bool dominates(Value a, Operation *b) const {
     return (Operation *)a.getDefiningOp() == b || properlyDominates(a, b);
   }
 
   /// Return true if the specified block A dominates block B.
-  bool dominates(Block *a, Block *b) {
+  bool dominates(Block *a, Block *b) const {
     return a == b || properlyDominates(a, b);
   }
 
   /// Return true if the specified block A properly dominates block B.
-  bool properlyDominates(Block *a, Block *b) {
+  bool properlyDominates(Block *a, Block *b) const {
     return super::properlyDominates(a, b);
   }
 
   /// Update the internal DFS numbers for the dominance nodes.
   void updateDFSNumbers();
 };
 
 /// A class for computing basic postdominance information.

mlir/lib/Analysis/Dominance.cpp

 DominanceInfoNode *DominanceInfoBase<IsPostDom>::getNode(Block *a) {
   auto *region = a->getParent();
   assert(dominanceInfos.count(region) != 0);
   return dominanceInfos[region]->getNode(a);
 }
 
 /// Return true if the specified block A properly dominates block B.
 template <bool IsPostDom>
-bool DominanceInfoBase<IsPostDom>::properlyDominates(Block *a, Block *b) {
+bool DominanceInfoBase<IsPostDom>::properlyDominates(Block *a, Block *b) const {
   // A block dominates itself but does not properly dominate itself.
   if (a == b)
     return false;
 
   // If either a or b are null, then conservatively return false.
   if (!a || !b)
     return false;
 

 template class mlir::detail::DominanceInfoBase</*IsPostDom=*/true>;
 template class mlir::detail::DominanceInfoBase</*IsPostDom=*/false>;
 
 //===----------------------------------------------------------------------===//
 // DominanceInfo
 //===----------------------------------------------------------------------===//
 
 /// Return true if operation A properly dominates operation B.
-bool DominanceInfo::properlyDominates(Operation *a, Operation *b) {
+bool DominanceInfo::properlyDominates(Operation *a, Operation *b) const {
   auto *aBlock = a->getBlock(), *bBlock = b->getBlock();
 
   // If a or b are not within a block, then a does not dominate b.
   if (!aBlock || !bBlock)
     return false;
 
   // If the blocks are the same, then check if b is before a in the block.
   if (aBlock == bBlock)
     return a->isBeforeInBlock(b);
 
   // Traverse up b's hierarchy to check if b's block is contained in a's.
   if (auto *bAncestor = aBlock->findAncestorOpInBlock(*b)) {
     // Since we already know that aBlock != bBlock, here bAncestor != b.
     // a and bAncestor are in the same block; check if 'a' dominates
     // bAncestor.
     return dominates(a, bAncestor);
   }
 
   // If the blocks are different, check if a's block dominates b's.
   return properlyDominates(aBlock, bBlock);
 }
 
 /// Return true if value A properly dominates operation B.
-bool DominanceInfo::properlyDominates(Value a, Operation *b) {
+bool DominanceInfo::properlyDominates(Value a, Operation *b) const {
   if (auto *aOp = a.getDefiningOp()) {
     // The values defined by an operation do *not* dominate any nested
     // operations.
     if (aOp->getParentRegion() != b->getParentRegion() && aOp->isAncestor(b))
       return false;
     return properlyDominates(aOp, b);
   }