[mlir][Arith] Make previous load-bearing assert into a real error

[krzysz00]

Summary

When I landed the EmulateUnsupportedFloats, I'd negligently included
an assert that needed to run for the pass to be correct. Previous
emergency fix commits removed the assert. This commit re-adds the
"can't happen" testing as an emitOpError() and aborting the rewrite,
thus allowing it to function in no-assertions builds.

[kuhar]

mlir/lib/Dialect/Arith/Transforms/EmulateUnsupportedFloats.cpp

85–87

uber-nit: Do we need this local variable? This is fine, but I'm more used to seeing:

if (failed(converter->convertTypes(op->getResultTypes(), resultTypes)))
  ...

89

nit: I don't think the part after the comma adds much, I'd remove it

[krzysz00]

Address review nits

mlir/lib/Dialect/Arith/Transforms/EmulateUnsupportedFloats.cpp

 
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/ErrorHandling.h"
 #include <optional>
 
 namespace mlir::arith {
 #define GEN_PASS_DEF_ARITHEMULATEUNSUPPORTEDFLOATS
 #include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
 } // namespace mlir::arith
 
 using namespace mlir;
LogicalResult EmulateFloatPattern::match(Operation *op) const {
   return success();
 }
 
 void EmulateFloatPattern::rewrite(Operation *op, ArrayRef<Value> operands,
                                   ConversionPatternRewriter &rewriter) const {
   Location loc = op->getLoc();
   TypeConverter *converter = getTypeConverter();
   SmallVector<Type> resultTypes;
-  LogicalResult pass = converter->convertTypes(op->getResultTypes(), resultTypes);
-  (void) pass;
+  LogicalResult didConvert =
+      converter->convertTypes(op->getResultTypes(), resultTypes);
+  if (failed(didConvert)) {
+    op->emitOpError(
+        "type conversion failed in float emulation, this can't happen");
+    return;
+  }
   Operation *expandedOp =
       rewriter.create(loc, op->getName().getIdentifier(), operands, resultTypes,
                       op->getAttrs(), op->getSuccessors(), /*regions=*/{});
   SmallVector<Value> newResults(expandedOp->getResults());
   for (auto [res, oldType, newType] : llvm::zip_equal(
            MutableArrayRef{newResults}, op->getResultTypes(), resultTypes)) {
     if (oldType != newType)
       res = rewriter.create<arith::TruncFOp>(loc, oldType, res);