[mlir][transform] ApplyConversionPatternsOp: Make conversion target optional

[springerm]

Summary

A conversion target is not needed. In a partial dialect conversion, ops are rewritten when possible. The dialect conversion succeeds if there are no illegal ops in the resulting IR.

Depends On: D157594

mlir/include/mlir/Dialect/Transform/IR/TransformOps.td

let description = [{
     conversion pattern descriptor can optionally specify a type converter in its
     `getTypeConverter` interface method. If no type converter is specified in
     this method, the default type converter of the dialect conversion is used.
     Default type converters are useful if the same type converter should be used
     for multiple sets of conversion patterns. (Patterns that should not use this
     default type converter specify their own type converter.)
 
     The `legal_ops`, `illegal_ops`, `legal_dialects`, `illegal_dialects`
-    attributes specify the conversion target. At least one of those four
-    attributes must be specified.
+    attributes specify the conversion target.
 
     This transform consumes the `target` handle and modifies the payload. It
     does not produce any handles.
 
     This transform fails silently if the dialect conversion was unsuccessful.
   }];
 
   let arguments = (ins TransformHandleTypeInterface:$target,

mlir/lib/Dialect/Transform/IR/TransformOps.cpp

if (!getPatterns().empty()) {
       for (Operation &op : getPatterns().front()) {
         auto descriptor =
             cast<transform::ConversionPatternDescriptorOpInterface>(&op);
         if (failed(descriptor.verifyTypeConverter(typeConverterOp)))
           return failure();
       }
     }
   }
-  if (!getLegalOps() && !getIllegalOps() && !getLegalDialects() &&
-      !getIllegalDialects())
-    return emitOpError() << "conversion target is not specified";
   return success();
 }
 
 void transform::ApplyConversionPatternsOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   transform::consumesHandle(getTarget(), effects);
   transform::modifiesPayload(effects);
 }

mlir/test/Dialect/Transform/test-pattern-application.mlir

transform.apply_conversion_patterns to %0 {
      partial_conversion} : !transform.any_op
 }
 
 // -----
 
 transform.sequence failures(propagate) {
 ^bb1(%arg1: !transform.any_op):
   %0 = transform.structured.match ops{["func.func"]} in %arg1 : (!transform.any_op) -> !transform.any_op
-  // expected-error @below{{conversion target is not specified}}
-  transform.apply_conversion_patterns to %0 {
-    transform.apply_conversion_patterns.transform.test_conversion_patterns
-  } with type_converter {
-    transform.apply_conversion_patterns.transform.test_type_converter
-  } : !transform.any_op
-}
-
-// -----
-
-transform.sequence failures(propagate) {
-^bb1(%arg1: !transform.any_op):
-  %0 = transform.structured.match ops{["func.func"]} in %arg1 : (!transform.any_op) -> !transform.any_op
   // expected-error @below{{pattern descriptor does not specify type converter and apply_conversion_patterns op has no default type converter}}
   transform.apply_conversion_patterns to %0 {
     // expected-note @below{{pattern descriptor op}}
     transform.apply_conversion_patterns.transform.test_conversion_patterns
   } {illegal_ops = ["test.foo"]} : !transform.any_op
 }
 
 // -----