[mlir] Define transform dialect expensive checks regardless of asserts.

[stellaraccident]

Summary

We shouldn't be varying public API surface based on NDEBUG. Prior to this patch, a release/installed MLIR could not be used from an assertions enabled consuming project.

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

 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include <optional>
 
 namespace mlir {
 namespace transform {
-#ifndef NDEBUG
 namespace detail {
 /// Asserts that the operations provided as template arguments implement the
 /// TransformOpInterface and MemoryEffectsOpInterface. This must be a dynamic
 /// assertion since interface implementations may be registered at runtime.
-void checkImplementsTransformOpInterface(StringRef name, MLIRContext *context);
+/// No-op if assertions are not enabled (but can be conditioned at the call-site
+/// to avoid an opaque function call).
+void assertImplementsTransformOpInterface(StringRef name, MLIRContext *context);
 
 /// Asserts that the type provided as template argument implements the
 /// TransformHandleTypeInterface. This must be a dynamic assertion since
 /// interface implementations may be registered at runtime.
-void checkImplementsTransformHandleTypeInterface(TypeID typeID,
+/// No-op if assertions are not enabled (but can be conditioned at the call-site
+/// to avoid an opaque function call).
+void assertImplementsTransformHandleTypeInterface(TypeID typeID,
                                                   MLIRContext *context);
 } // namespace detail
-#endif // NDEBUG
 } // namespace transform
 } // namespace mlir
 
 #include "mlir/Dialect/Transform/IR/TransformDialect.h.inc"
 
 namespace mlir {
 namespace transform {
 

 template <typename OpTy>
 void TransformDialect::addOperationIfNotRegistered() {
   StringRef name = OpTy::getOperationName();
   std::optional<RegisteredOperationName> opName =
       RegisteredOperationName::lookup(name, getContext());
   if (!opName) {
     addOperations<OpTy>();
 #ifndef NDEBUG
-    detail::checkImplementsTransformOpInterface(name, getContext());
+    detail::assertImplementsTransformOpInterface(name, getContext());
 #endif // NDEBUG
     return;
   }
 
   if (opName->getTypeID() == TypeID::get<OpTy>())
     return;
 
   reportDuplicateOpRegistration(name);
void TransformDialect::addTypeIfNotRegistered() {
   typePrintingHooks.try_emplace(
       TypeID::get<Type>(), +[](mlir::Type type, AsmPrinter &printer) {
         printer << Type::getMnemonic();
         cast<Type>(type).print(printer);
       });
   addTypes<Type>();
 
 #ifndef NDEBUG
-  detail::checkImplementsTransformHandleTypeInterface(TypeID::get<Type>(),
+  detail::assertImplementsTransformHandleTypeInterface(TypeID::get<Type>(),
                                                        getContext());
 #endif // NDEBUG
 }
 
 /// A wrapper for transform dialect extensions that forces them to be
 /// constructed in the build-only mode.
 template <typename DerivedTy>
 class BuildOnly : public DerivedTy {
 public:

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

 #include "mlir/Dialect/Transform/IR/TransformOps.h"
 #include "mlir/Dialect/Transform/IR/TransformTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 
 using namespace mlir;
 
 #include "mlir/Dialect/Transform/IR/TransformDialect.cpp.inc"
 
-#ifndef NDEBUG
-void transform::detail::checkImplementsTransformOpInterface(
+void transform::detail::assertImplementsTransformOpInterface(
     StringRef name, MLIRContext *context) {
   // Since the operation is being inserted into the Transform dialect and the
   // dialect does not implement the interface fallback, only check for the op
   // itself having the interface implementation.
   RegisteredOperationName opName =
       *RegisteredOperationName::lookup(name, context);
+  (void)opName;
   assert((opName.hasInterface<TransformOpInterface>() ||
           opName.hasTrait<OpTrait::IsTerminator>()) &&
          "non-terminator ops injected into the transform dialect must "
          "implement TransformOpInterface");
   assert(opName.hasInterface<MemoryEffectOpInterface>() &&
          "ops injected into the transform dialect must implement "
          "MemoryEffectsOpInterface");
 }
 
-void transform::detail::checkImplementsTransformHandleTypeInterface(
+void transform::detail::assertImplementsTransformHandleTypeInterface(
     TypeID typeID, MLIRContext *context) {
   const auto &abstractType = AbstractType::lookup(typeID, context);
+  (void)abstractType;
   assert((abstractType.hasInterface(
               TransformHandleTypeInterface::getInterfaceID()) ||
           abstractType.hasInterface(
               TransformParamTypeInterface::getInterfaceID()) ||
           abstractType.hasInterface(
               TransformValueHandleTypeInterface::getInterfaceID())) &&
          "expected Transform dialect type to implement one of the three "
          "interfaces");
 }
-#endif // NDEBUG
 
 namespace {
 struct PDLOperationTypeTransformHandleTypeInterfaceImpl
     : public transform::TransformHandleTypeInterface::ExternalModel<
           PDLOperationTypeTransformHandleTypeInterfaceImpl,
           pdl::OperationType> {
   DiagnosedSilenceableFailure
   checkPayload(Type type, Location loc, ArrayRef<Operation *> payload) const {