[mlir][Transform] Fix isDefiniteFailure helper

[nicolasvasilache]

Summary

This newly added helper was returning definiteFailure even in the case of silenceableFailure.

[nicolasvasilache]

Uniformize the 3 success/failure helpers.

[springerm]

mlir/test/Dialect/Linalg/transform-op-pad.mlir

112–113

typo

[nicolasvasilache]

Address typo.

mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h

if (!diagnostics.empty()) {
             std::move(diagnostic));
       }
       diagnostics.clear();
       result = ::mlir::failure();
     }
     return result;
   }
 
-  /// Returns `true` if this is a silenceable failure.
-  bool isDefiniteFailure() const { return result.failed(); }
-
-  /// Returns `true` if this is a silenceable failure.
-  bool isSilenceableFailure() const { return !diagnostics.empty(); }
-
   /// Returns `true` if this is a success.
   bool succeeded() const {
-    return diagnostics.empty() && ::mlir::succeeded(result);
+    return ::mlir::succeeded(result) && diagnostics.empty();
   }
 
+  /// Returns `true` if this is a definite failure.
+  bool isDefiniteFailure() const {
+    return ::mlir::failed(result) && diagnostics.empty();
+  }
+
+  /// Returns `true` if this is a silenceable failure.
+  bool isSilenceableFailure() const { return !diagnostics.empty(); }
+
   /// Returns the diagnostic message without emitting it. Expects this object
   /// to be a silenceable failure.
   std::string getMessage() const {
     std::string res;
     for (auto &diagnostic : diagnostics) {
       res.append(diagnostic.str());
       res.append("\n");
     }

mlir/test/Dialect/Linalg/transform-op-pad.mlir

^bb0(%arg0: !pdl.operation):
   }
 }
 
 // -----
 
 func.func @pad(%arg0: tensor<24x12xf32>,
                %arg1: tensor<12x25xf32>,
                %arg2: tensor<24x25xf32>) -> tensor<24x25xf32> {
-  // expected-note @below {{when applied to this op}}
+  // This is attached to an error that is silenceable and is not reported by this transform
+  //   {{when applied to this op}}
   %0 = linalg.matmul ins(%arg0, %arg1 : tensor<24x12xf32>, tensor<12x25xf32>) outs(%arg2 : tensor<24x25xf32>) -> tensor<24x25xf32>
   func.return %0 : tensor<24x25xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @pdl_target : benefit(1) {
     %args = operands
     %results = types
     %0 = pdl.operation "linalg.matmul"(%args : !pdl.range<value>) -> (%results : !pdl.range<type>)
     // TODO: we don't want this, but it is the required terminator for pdl.pattern
     rewrite %0 with "transform.dialect"
   }
 
   transform.sequence %arg0 {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @pdl_target in %arg1
-    // expected-error @below {{transform.structured.pad failed to apply}}
+    // This error is silenceable and is not reported by this transform
+    //   {{transform.structured.pad failed to apply}}
     %1 = transform.structured.pad %0 {padding_values=[0.0 : f32, 0.0 : f32, 0.0 : f32], padding_dimensions=[0, 1, 2], pack_paddings=[1, 1, 0]}
   }
 }

mlir/test/Dialect/Transform/test-interpreter.mlir

^bb0(%arg0: !pdl.operation):
   transform.sequence %arg0 {
   ^bb0(%arg1: !pdl.operation):
     %0 = pdl_match @addi in %arg1
     %1 = pdl_match @subi in %arg1
     %2 = merge_handles %0, %1
     test_print_remark_at_operand %2, "matched"
   }
 }
+
+// -----
+
+func.func @foo() {
+  "op" () { target_me } : () -> ()
+  "op" () : () -> ()
+  return
+}
+
+transform.with_pdl_patterns {
+^bb0(%arg0: !pdl.operation):
+  pdl.pattern @some : benefit(1) {
+    %0 = pdl.operands
+    %1 = pdl.types
+    %2 = pdl.operation "op"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
+    pdl.rewrite %2 with "transform.dialect"
+  }
+
+  transform.sequence %arg0 {
+  ^bb0(%arg1: !pdl.operation):
+    %0 = pdl_match @some in %arg1
+    transform.test_mixed_sucess_and_silenceable %0
+  }
+}

mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp

mlir::test::TestMixedNullAndNonNullResultsOp::applyToOne(
     Operation *target, SmallVectorImpl<Operation *> &results,
     transform::TransformState &state) {
   OperationState opState(target->getLoc(), "foo");
   results.push_back(nullptr);
   results.push_back(OpBuilder(target).create(opState));
   return DiagnosedSilenceableFailure::success();
 }
 
+DiagnosedSilenceableFailure
+mlir::test::TestMixedSuccessAndSilenceableOp::applyToOne(
+    Operation *target, SmallVectorImpl<Operation *> &results,
+    transform::TransformState &state) {
+  if (target->hasAttr("target_me"))
+    return DiagnosedSilenceableFailure::success();
+  return emitDefaultSilenceableFailure(target);
+}
+
 namespace {
 /// Test extension of the Transform dialect. Registers additional ops and
 /// declares PDL as dependent dialect since the additional ops are using PDL
 /// types for operands and results.
 class TestTransformDialectExtension
     : public transform::TransformDialectExtension<
           TestTransformDialectExtension> {
 public:

mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td

def TestMixedNullAndNonNullResultsOp
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
         ::mlir::Operation * target, 
         ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
         ::mlir::transform::TransformState &state);
   }];
 }
 
+def TestMixedSuccessAndSilenceableOp
+  : Op<Transform_Dialect, "test_mixed_sucess_and_silenceable",
+    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface, 
+     TransformEachOpTrait, TransformOpInterface]> {
+  let arguments = (ins PDL_Operation:$target);
+  let results = (outs);
+  let assemblyFormat = "$target attr-dict";
+  let cppNamespace = "::mlir::test";
+  let extraClassDeclaration = [{
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::Operation * target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
+  }];
+}
+
 #endif // MLIR_TESTTRANSFORMDIALECTEXTENSION_TD