[NFC] Generically resolve body in FunctionOpInterface verifyBody.

[stellaraccident]

Summary

Since the actual implementation class can arbitrarily shadow parts of the FunctionOpInterface exported API, access the body generically instead of via the use of the interface being defined.

Fixes https://github.com/llvm/llvm-project/issues/54807

mlir/include/mlir/IR/FunctionInterfaces.td

InterfaceMethod<[{
       Note: The default implementation merely checks that if the entry block
       exists, it has the same number and type of arguments as the function type.
     }],
     "::mlir::LogicalResult", "verifyBody", (ins),
     /*methodBody=*/[{}], /*defaultImplementation=*/[{
       if ($_op.isExternal())
         return success();
       ArrayRef<Type> fnInputTypes = $_op.getArgumentTypes();
-      Block &entryBlock = $_op.front();
-    
+      // NOTE: This should just be $_op.front() but access generically
+      // because the interface methods defined here may be shadowed in
+      // arbitrary ways. https://github.com/llvm/llvm-project/issues/54807
+      Block &entryBlock = $_op->getRegion(0).front();
       unsigned numArguments = fnInputTypes.size();
       if (entryBlock.getNumArguments() != numArguments)
         return $_op.emitOpError("entry block must have ")
               << numArguments << " arguments to match function signature";
 
       for (unsigned i = 0, e = fnInputTypes.size(); i != e; ++i) {
         Type argType = entryBlock.getArgument(i).getType();
         if (fnInputTypes[i] != argType) {
static void buildWithEntryBlock(
       state.attributes.append(attrs.begin(), attrs.end());
 
       // Add the function body.
       Region *bodyRegion = state.addRegion();
       Block *body = new Block();
       bodyRegion->push_back(body);
       for (Type input : inputTypes)
         body->addArgument(input, state.location);
-    } 
+    }
   }];
   let extraSharedClassDeclaration = [{
     /// Block list iterator types.
     using BlockListType = Region::BlockListType;
     using iterator = BlockListType::iterator;
     using reverse_iterator = BlockListType::reverse_iterator;
 
     /// Block argument iterator types.
     using BlockArgListType = Region::BlockArgListType;
     using args_iterator = BlockArgListType::iterator;
-    
     //===------------------------------------------------------------------===//
     // Body Handling
     //===------------------------------------------------------------------===//
 
     /// Returns true if this function is external, i.e. it has no body.
     bool isExternal() { return empty(); }
 
     /// Return the region containing the body of this function.
let extraSharedClassDeclaration = [{
 
     /// Add an entry block to an empty function, and set up the block arguments
     /// to match the signature of the function. The newly inserted entry block
     /// is returned.
     Block *addEntryBlock() {
       assert(empty() && "function already has an entry block");
       Block *entry = new Block();
       push_back(entry);
-      
       // FIXME: Allow for passing in locations for these arguments instead of using
       // the operations location.
       ArrayRef<Type> inputTypes = $_op.getArgumentTypes();
       SmallVector<Location> locations(inputTypes.size(),
                                       $_op.getOperation()->getLoc());
       entry->addArguments(inputTypes, locations);
       return entry;
     }