[mlir] DialectConversion: remove vtable from TypeConverter

[ftynse]

Summary

The original design of TypeConverter expected specific converters to derive the
class and override virtual functions for conversions and materializations. This
did not scale well to multi-dialect conversions, so the design was changed to
register a list of converter and materializer functions, removing the need for
virtual functions. The only remaining virtual function, convertSignatureArg
is never overridden in-tree. Make it non-virtual, drop the virtual destructor
and thus remove vtable from TypeConverter.

If there exist TypeConverter users that need custom convertSignatureArg
behavior, it should be implemented using the callback registration mechanism
similar to that of conversions and materializations.

Depends On D79729

[rriddle]

mlir/include/mlir/Transforms/DialectConversion.h

157

nit: hook -> method?

mlir/include/mlir/Transforms/DialectConversion.h

 class Operation;
 class Type;
 class Value;
 
 //===----------------------------------------------------------------------===//
 // Type Conversion
 //===----------------------------------------------------------------------===//
 
-/// Base class for type conversion interface. Specific converters must
-/// derive this class and implement the pure virtual functions.
+/// Type conversion class. Specific conversions and materializations can be
+/// registered using addConversion and addMaterialization, respectively.
 class TypeConverter {
 public:
-  virtual ~TypeConverter() = default;
-
   /// This class provides all of the information necessary to convert a type
   /// signature.
   class SignatureConversion {
   public:
     SignatureConversion(unsigned numOrigInputs)
         : remappedInputs(numOrigInputs) {}
 
     /// This struct represents a range of new types or a single value that
public:
   /// Return true if the given type is legal for this type converter, i.e. the
   /// type converts to itself.
   bool isLegal(Type type);
 
   /// Return true if the inputs and outputs of the given function type are
   /// legal.
   bool isSignatureLegal(FunctionType funcType);
 
-  /// This hook allows for converting a specific argument of a signature. It
+  /// This method allows for converting a specific argument of a signature. It
   /// takes as inputs the original argument input number, type.
-  /// On success, this function should populate 'result' with any new mappings.
-  virtual LogicalResult convertSignatureArg(unsigned inputNo, Type type,
-                                            SignatureConversion &result);
+  /// On success, it populates 'result' with any new mappings.
+  LogicalResult convertSignatureArg(unsigned inputNo, Type type,
 
   /// This function converts the type signature of the given block, by invoking
   /// 'convertSignatureArg' for each argument. This function should return a
   /// valid conversion for the signature on success, None otherwise.
   Optional<SignatureConversion> convertBlockSignature(Block *block);
 
   /// Materialize a conversion from a set of types into one result type by
   /// generating a cast operation of some kind.