[mlir][DialectConversion] Add overload of addDynamicallyLegalDialect to support lambdas

[rriddle]

Summary

This allows for passing a lambda to addDynamicallyLegalDialect without needing to explicit wrap with Optional<DynamicLegalityCallbackFn>.

Depends On D81679

mlir/include/mlir/Transforms/DialectConversion.h

public:
   template <typename... Args>
   void addDynamicallyLegalDialect(
       Optional<DynamicLegalityCallbackFn> callback = llvm::None) {
     SmallVector<StringRef, 2> dialectNames({Args::getDialectNamespace()...});
     setDialectAction(dialectNames, LegalizationAction::Dynamic);
     if (callback)
       setLegalityCallback(dialectNames, *callback);
   }
+  template <typename... Args>
+  void addDynamicallyLegalDialect(DynamicLegalityCallbackFn callback) {
+    SmallVector<StringRef, 2> dialectNames({Args::getDialectNamespace()...});
+    setDialectAction(dialectNames, LegalizationAction::Dynamic);
+    setLegalityCallback(dialectNames, callback);
+  }
 
   /// Register unknown operations as dynamically legal. For operations(and
   /// dialects) that do not have a set legalization action, treat them as
   /// dynamically legal and invoke the given callback if valid or
   /// 'isDynamicallyLegal'.
   void markUnknownOpDynamicallyLegal(const DynamicLegalityCallbackFn &fn) {
     unknownOpsDynamicallyLegal = true;
     unknownLegalityFn = fn;

mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp

 
 std::unique_ptr<spirv::SPIRVConversionTarget>
 spirv::SPIRVConversionTarget::get(spirv::TargetEnvAttr targetAttr) {
   std::unique_ptr<SPIRVConversionTarget> target(
       // std::make_unique does not work here because the constructor is private.
       new SPIRVConversionTarget(targetAttr));
   SPIRVConversionTarget *targetPtr = target.get();
   target->addDynamicallyLegalDialect<SPIRVDialect>(
-      Optional<ConversionTarget::DynamicLegalityCallbackFn>(
-          // We need to capture the raw pointer here because it is stable:
-          // target will be destroyed once this function is returned.
-          [targetPtr](Operation *op) { return targetPtr->isLegalOp(op); }));
+      [targetPtr](Operation *op) { return targetPtr->isLegalOp(op); });
   return target;
 }
 
 spirv::SPIRVConversionTarget::SPIRVConversionTarget(
     spirv::TargetEnvAttr targetAttr)
     : ConversionTarget(*targetAttr.getContext()), targetEnv(targetAttr) {}
 
 bool spirv::SPIRVConversionTarget::isLegalOp(Operation *op) {

mlir/test/lib/Transforms/TestBufferPlacement.cpp

void runOnOperation() override {
 
     // Mark all Standard operations legal.
     target.addLegalDialect<StandardOpsDialect>();
 
     // Mark all Linalg operations illegal as long as they work on tensors.
     auto isLegalOperation = [&](Operation *op) {
       return converter.isLegal(op);
     };
-    target.addDynamicallyLegalDialect<linalg::LinalgDialect>(
-        Optional<ConversionTarget::DynamicLegalityCallbackFn>(
-            isLegalOperation));
+    target.addDynamicallyLegalDialect<linalg::LinalgDialect>(isLegalOperation);
 
     // Mark Standard Return operations illegal as long as one operand is tensor.
     target.addDynamicallyLegalOp<mlir::ReturnOp>([&](mlir::ReturnOp returnOp) {
       return converter.isLegal(returnOp.getOperandTypes());
     });
 
     // Mark Standard Call Operation illegal as long as it operates on tensor.
     target.addDynamicallyLegalOp<mlir::CallOp>(