[mlir][bufferize][NFC] Remove old references to Comprehensive Bufferize

[springerm]

Summary

Depends On D124323

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.td

 //===-- BufferizableOpInterface.td - Bufferizable Ops ------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BUFFERIZABLE_OP_INTERFACE
 #define BUFFERIZABLE_OP_INTERFACE
 
 include "mlir/IR/OpBase.td"
 
 def BufferizableOpInterface : OpInterface<"BufferizableOpInterface"> {
   let description = [{
-    An op interface for Comprehensive Bufferization. Ops that implement this
-    interface can be bufferized using Comprehensive Bufferization.
+    An op interface for One-Shot Bufferize. Ops that implement this interface
+    interface can be analyzed and bufferized using One-Shot Bufferize.
   }];
   let cppNamespace = "::mlir::bufferization";
   let methods = [
       InterfaceMethod<
         /*desc=*/[{
           Return `true` if the given OpOperand bufferizes to a memory read. This
           method will never be called on OpOperands that do not have a tensor
           type.
 
           Note: It is always safe to consider an OpOperand as a memory read,
           even if it does actually not read; however, this can introduce
-          unnecessary out-of-place bufferization decisions. The analysis of
-          Comprehensive Bufferize considers OpOperands of unknown ops (that do
-          not implement this interface) as reading OpOperands.
+          unnecessary out-of-place bufferization decisions. One-Shot Analysis
+          considers OpOperands of unknown ops (that do not implement this
+          interface) as reading OpOperands.
         }],
         /*retType=*/"bool",
         /*methodName=*/"bufferizesToMemoryRead",
         /*args=*/(ins "OpOperand &":$opOperand,
                       "const AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           // Does not have to be implemented for ops without tensor OpOperands.
let methods = [
           This method will never be called on OpOperands that do not have an
           aliasing OpResult. Intuitively, it does not make sense for an
           OpOperand to bufferize to a memory write without returning an aliasing
           tensor, because the write would have no visible effect outside of the
           op.
 
           Note: It is always safe to consider an OpOperand as a memory write,
           even if it does actually not write; however, this can introduce
-          unnecessary out-of-place bufferization decisions. The analysis of
-          Comprehensive Bufferize considers OpOperands of unknown ops (that do
-          not implement this interface) as writing OpOperands.
+          unnecessary out-of-place bufferization decisions. One-Shot Analysis
+          considers OpOperands of unknown ops (that do not implement this
+          interface) as writing OpOperands.
         }],
         /*retType=*/"bool",
         /*methodName=*/"bufferizesToMemoryWrite",
         /*args=*/(ins "OpOperand &":$opOperand,
                       "const AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           // Does not have to be implemented for ops without tensor OpOperands.