[mlir:PDLL] Fix the import of native constraints from ODS

[rriddle]

Summary

We weren't properly returning the result of the constraint,
which leads to errors when actually trying to use the generated
C++.

Depends on D124585

[jpienaar]

mlir/test/mlir-pdll/Integration/test-pdll.mlir

13

Could you add another op that doesn't implement interface too? E.g if we had accidentally not checked properly for success it would show

mlir/lib/Tools/PDLL/Parser/Parser.cpp

for (llvm::Record *def : tdRecords.getAllDerivedDefinitions("Interface")) {
     if (def->isAnonymous() || curDeclScope->lookup(name) ||
         def->isSubClassOf("DeclareInterfaceMethods"))
       continue;
     SMRange loc = convertLocToRange(def->getLoc().front());
 
     StringRef className = def->getValueAsString("cppClassName");
     StringRef cppNamespace = def->getValueAsString("cppNamespace");
     std::string codeBlock =
-        llvm::formatv("llvm::isa<{0}::{1}>(self)", cppNamespace, className)
+        llvm::formatv("return ::mlir::success(llvm::isa<{0}::{1}>(self));",
+                      cppNamespace, className)
             .str();
 
     if (def->isSubClassOf("OpInterface")) {
       decls.push_back(createODSNativePDLLConstraintDecl<ast::OpConstraintDecl>(
           name, codeBlock, loc, opTy));
     } else if (def->isSubClassOf("AttrInterface")) {
       decls.push_back(
           createODSNativePDLLConstraintDecl<ast::AttrConstraintDecl>(

 
 template <typename ConstraintT>
 ast::Decl *
 Parser::createODSNativePDLLConstraintDecl(const tblgen::Constraint &constraint,
                                           SMRange loc, ast::Type type) {
   // Format the condition template.
   tblgen::FmtContext fmtContext;
   fmtContext.withSelf("self");
-  std::string codeBlock =
-      tblgen::tgfmt(constraint.getConditionTemplate(), &fmtContext);
+  std::string codeBlock = tblgen::tgfmt(
+      "return ::mlir::success(" + constraint.getConditionTemplate() + ");",
+      &fmtContext);
 
   return createODSNativePDLLConstraintDecl<ConstraintT>(
       constraint.getUniqueDefName(), codeBlock, loc, type);
 }
 
 //===----------------------------------------------------------------------===//
 // Decls
 

mlir/test/lib/Tools/PDLL/TestPDLL.pdll

 //===- TestPDLL.pdll - Test PDLL functionality ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestOps.td"
+#include "mlir/Interfaces/CastInterfaces.td"
 
 /// A simple pattern that matches and replaces an operation.
 Pattern TestSimplePattern => replace op<test.simple> with op<test.success>;
+
+// Test the import of interfaces.
+Pattern TestInterface => replace _: CastOpInterface with op<test.success>;

mlir/test/mlir-pdll/Integration/test-pdll.mlir

 // RUN: mlir-opt %s -test-pdll-pass | FileCheck %s
 
 // CHECK-LABEL: func @simpleTest
 func @simpleTest() {
   // CHECK: test.success
   "test.simple"() : () -> ()
   return
 }
+
+// CHECK-LABEL: func @testImportedInterface
+func @testImportedInterface() {
+  // CHECK: test.success
+  "builtin.unrealized_conversion_cast"() : () -> (i1)
+  return
+}

mlir/test/mlir-pdll/Parser/include_td.pdll

 // CHECK-NEXT:   CppClass: ::mlir::IntegerAttr
 // CHECK-NEXT: }
 
 // CHECK:      TypeConstraint `I64` {
 // CHECK-NEXT:   Summary: 64-bit signless integer
 // CHECK-NEXT:   CppClass: ::mlir::IntegerType
 // CHECK-NEXT: }
 
-// CHECK: UserConstraintDecl {{.*}} Name<TestAttrInterface> ResultType<Tuple<>> Code<llvm::isa<::TestAttrInterface>(self)>
+// CHECK: UserConstraintDecl {{.*}} Name<TestAttrInterface> ResultType<Tuple<>> Code<return ::mlir::success(llvm::isa<::TestAttrInterface>(self));>
 // CHECK:  `Inputs`
 // CHECK:    `-VariableDecl {{.*}} Name<self> Type<Attr>
 // CHECK:      `Constraints`
 // CHECK:        `-AttrConstraintDecl
 
-// CHECK: UserConstraintDecl {{.*}} Name<TestOpInterface> ResultType<Tuple<>> Code<llvm::isa<::TestOpInterface>(self)>
+// CHECK: UserConstraintDecl {{.*}} Name<TestOpInterface> ResultType<Tuple<>> Code<return ::mlir::success(llvm::isa<::TestOpInterface>(self));>
 // CHECK:  `Inputs`
 // CHECK:    `-VariableDecl {{.*}} Name<self> Type<Op>
 // CHECK:      `Constraints`
 // CHECK:        `-OpConstraintDecl
 // CHECK:          `-OpNameDecl
 
-// CHECK: UserConstraintDecl {{.*}} Name<TestTypeInterface> ResultType<Tuple<>> Code<llvm::isa<::TestTypeInterface>(self)>
+// CHECK: UserConstraintDecl {{.*}} Name<TestTypeInterface> ResultType<Tuple<>> Code<return ::mlir::success(llvm::isa<::TestTypeInterface>(self));>
 // CHECK:  `Inputs`
 // CHECK:    `-VariableDecl {{.*}} Name<self> Type<Type>
 // CHECK:      `Constraints`
 // CHECK:        `-TypeConstraintDecl {{.*}}