[Verifier] Inline a method to simplify the code in preparation for bigger changes, NFC.

[lattner]

Self approving as "obvious"

mlir/lib/IR/Verifier.cpp

public:
   LogicalResult verifyOpAndDominance(Operation &op);
 
 private:
   /// Verify the given potentially nested region or block.
   LogicalResult verifyRegion(Region &region);
   LogicalResult verifyBlock(Block &block);
   LogicalResult verifyOperation(Operation &op);
 
-  /// Verify the dominance property of operations within the given Region.
-  LogicalResult verifyDominance(Region &region);
-
   /// Verify the dominance property of regions contained within the given
   /// Operation.
   LogicalResult verifyDominanceOfContainedRegions(Operation &op);
 
   /// Emit an error for the given block.
   InFlightDiagnostic emitError(Block &bb, const Twine &message) {
     // Take the location information for the first operation in the block.
     if (!bb.empty())
static void diagnoseInvalidOperandDominance(Operation &op, unsigned operandNo) {
   else if (region2->isProperAncestor(region1))
     note << " in a parent region)";
   else if (region1->isProperAncestor(region2))
     note << " in a child region)";
   else
     note << " neither in a parent nor in a child region)";
 }
 
-LogicalResult OperationVerifier::verifyDominance(Region &region) {
+/// Verify the dominance of each of the nested blocks within the given operation
+LogicalResult
+OperationVerifier::verifyDominanceOfContainedRegions(Operation &op) {
+  for (Region &region : op.getRegions()) {
     // Verify the dominance of each of the held operations.
     for (Block &block : region) {
       // Dominance is only meaningful inside reachable blocks.
       bool isReachable = domInfo->isReachableFromEntry(&block);
 
       for (Operation &op : block) {
         if (isReachable) {
           // Check that operands properly dominate this use.
           for (unsigned operandNo = 0, e = op.getNumOperands(); operandNo != e;
                ++operandNo) {
             if (domInfo->properlyDominates(op.getOperand(operandNo), &op))
               continue;
 
             diagnoseInvalidOperandDominance(op, operandNo);
             return failure();
           }
         }
 
         // Recursively verify dominance within each operation in the
         // block, even if the block itself is not reachable, or we are in
         // a region which doesn't respect dominance.
+        if (op.getNumRegions() != 0)
           if (failed(verifyDominanceOfContainedRegions(op)))
             return failure();
       }
     }
-  return success();
-}
-
-/// Verify the dominance of each of the nested blocks within the given operation
-LogicalResult
-OperationVerifier::verifyDominanceOfContainedRegions(Operation &op) {
-  for (Region &region : op.getRegions()) {
-    if (failed(verifyDominance(region)))
-      return failure();
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Entrypoint
 //===----------------------------------------------------------------------===//
 
 /// Perform (potentially expensive) checks of invariants, used to detect
 /// compiler bugs.  On error, this reports the error through the MLIRContext and
 /// returns failure.
 LogicalResult mlir::verify(Operation *op) {
   return OperationVerifier().verifyOpAndDominance(*op);
 }