[mlir][bufferize] Add helpers for templatized DENY filters

[springerm]

Summary

We already have templatized ALLOW filters but the DENY filters were missing.

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

void allowDialectInFilter() {
     // The following expands a call to allowDialectInFilterImpl for each dialect
     // in 'DialectTs'. This magic is necessary due to a limitation in the places
     // that a parameter pack can be expanded in c++11.
     // FIXME: In c++17 this can be simplified by using 'fold expressions'.
     (void)std::initializer_list<int>{
         0, (allowDialectInFilterImpl<DialectTs>(), 0)...};
   }
 
+  /// Deny the given dialects in the filter.
+  ///
+  /// This function adds one or multiple DENY filters.
+  template <typename... DialectTs>
+  void denyDialectInFilter() {
+    // FIXME: In c++17 this can be simplified by using 'fold expressions'.
+    (void)std::initializer_list<int>{
+        0, (denyDialectInFilterImpl<DialectTs>(), 0)...};
+  }
+
   /// Allow the given dialect in the filter.
   ///
   /// This function adds an ALLOW filter.
   void allowDialectInFilter(StringRef dialectNamespace) {
     OpFilterEntry::FilterFn filterFn = [=](Operation *op) {
       return op->getDialect()->getNamespace() == dialectNamespace;
     };
     opFilter.push_back(
         OpFilterEntry{filterFn, OpFilterEntry::FilterType::ALLOW});
   }
 
   /// Allow the given ops in the filter.
   ///
   /// This function adds one or multiple ALLOW filters.
   template <typename... OpTys>
   void allowOperationInFilter() {
     // FIXME: In c++17 this can be simplified by using 'fold expressions'.
     (void)std::initializer_list<int>{
         0, (allowOperationInFilterImpl<OpTys>(), 0)...};
   }
 
+  /// Deny the given ops in the filter.
+  ///
+  /// This function adds one or multiple DENY filters.
+  template <typename... OpTys>
+  void denyOperationInFilter() {
+    // FIXME: In c++17 this can be simplified by using 'fold expressions'.
+    (void)std::initializer_list<int>{
+        0, (denyOperationInFilterImpl<OpTys>(), 0)...};
+  }
+
   /// Allow the given op in the filter.
   ///
   /// This function adds an ALLOW filter.
   void allowOperationInFilter(StringRef opName) {
     OpFilterEntry::FilterFn filterFn = [=](Operation *op) {
       return op->getName().getStringRef() == opName;
     };
     allowOperationInFilter(filterFn);

 
 private:
   /// Allow a dialect.
   template <typename DialectT>
   void allowDialectInFilterImpl() {
     allowDialectInFilter(DialectT::getDialectNamespace());
   }
 
+  /// Deny a dialect.
+  template <typename DialectT>
+  void denyDialectInFilterImpl() {
+    denyDialectInFilter(DialectT::getDialectNamespace());
+  }
+
   /// Allow an op.
   template <typename OpTy>
   void allowOperationInFilterImpl() {
     allowOperationInFilter(OpTy::getOperationName());
   }
+
+  /// Deny an op.
+  template <typename OpTy>
+  void denyOperationInFilterImpl() {
+    denyOperationInFilter(OpTy::getOperationName());
+  }
 };
 
 /// Specify fine-grain relationship between buffers to enable more analysis.
 enum class BufferRelation {
   None,
   // TODO: ResultContainsOperand,
   // TODO: OperandContainsResult,
   Equivalent