Adjust assertion when casting to an unregistered operation

[mehdi_amini]

Summary

This assertion does not achieve what it meant to do originally, as it
would fire only when applied to an unregistered operation, which is a
fairly rare circumstance (it needs a dialect or context allowing
unregistered operation in the input in the first place).
Instead we relax it to only fire when it should have matched but didn't
because of the misconfiguration.

[rriddle]

The relationship between the op classes and registration feels under documented and easily error prone to new users. The fact that isa<AffineForOp>(op) will silently fail on an affine.for operation because the affine dialect isn't registered will likely feel wrong to many as an initial reaction. I'm not saying we should allow or encourage the use of the *Op classes when something is unregistered(we shouldn't), but it feels like we could make debugging/understanding a misconfiguration much easier; which if I recall is the original intention of the assert. E.g. as a bare bone hint, could we add a debug log that detects such situations and issues a message? e.g. something like:

LLVM_DEBUG({
  if (op->getName().getStringRef() == ConcreteType::getOperationName())
    dbgs() << "classof on '" << ConcreteType::getOperationName() << "' failed due to the operation not being registered\n";
})

[mehdi_amini]

The fact that isa<AffineForOp>(op) will silently fail on an affine.for operation because the affine dialect isn't registered will likely feel wrong to many as an initial reaction

My reasoning is that by default we don't allow to create an unregistered AffineForOp in the IR in the first place: the situation you're describing can only happen if the user use --allow-unregistered-dialects I believe.

But your suggestion seems fine as well for such cases!

[mehdi_amini]

Address comment

mlir/include/mlir/IR/OpDefinition.h

public:
 
   /// Return the parent Region of this operation.
   Region *getParentRegion() { return getOperation()->getParentRegion(); }
 
   /// Return true if this "op class" can match against the specified operation.
   static bool classof(Operation *op) {
     if (auto *abstractOp = op->getAbstractOperation())
       return TypeID::get<ConcreteType>() == abstractOp->typeID;
-    assert(op->getContext()->isOperationRegistered(
-               ConcreteType::getOperationName()) &&
-           "Casting attempt to an unregistered operation");
+#ifndef NDEBUG
+    if (op->getName().getStringRef() == ConcreteType::getOperationName())
+      llvm::report_fatal_error(
+          "classof on '" + ConcreteType::getOperationName() +
+          "' failed due to the operation not being registered");
+#endif
     return false;
   }
 
   /// This is the hook used by the AsmParser to parse the custom form of this
   /// op from an .mlir file.  Op implementations should provide a parse method,
   /// which returns failure.  On success, they should return fill in result with
   /// the fields to use.
   static ParseResult parseAssembly(OpAsmParser &parser,