[mlir][tensor] Remove element type constraint on SplatOp.

[ingomueller-net]

Summary

This patch allows AnyType as input type of tensor.splat. Previsously,
only integer and float types were allowed. The patch thus applies the
philosophy of the introduction of the dialect documentation, which says
that ops should "make sense for any tensor element type" (which is the
case for SplatOp).

[ingomueller-net]

With the goal of flushing my Phabricator pipeline, I expanded the set of reviewers.

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

def Tensor_SplatOp : Tensor_Op<"splat", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
     Pure,
     TypesMatchWith<"operand type matches element type of result",
                    "aggregate", "input",
                    "::llvm::cast<TensorType>($_self).getElementType()">
   ]> {
   let summary = "tensor splat or broadcast operation";
   let description = [{
-    Broadcast the operand to all elements of the result tensor. The operand is
-    required to be of integer/index/float type, and the result tensor must be
-    statically shaped.
+    Broadcast the operand to all elements of the result tensor. The result
+    tensor must be statically shaped.
 
     Example:
 
     ```mlir
     %s = arith.constant 10.1 : f32
     %t = tensor.splat %s : tensor<8x16xf32>
     ```
 
     TODO: This operation is easy to extend to broadcast to dynamically shaped
           tensors:
 
     ```mlir
     // Broadcasts %s to a 2-d dynamically shaped tensor, with %m, %n binding
     // to the sizes of the two dynamic dimensions.
     %m = "foo"() : () -> (index)
     %n = "bar"() : () -> (index)
     %t = tensor.splat %s [%m, %n] : tensor<?x?xf32>
     ```
   }];
 
-  let arguments = (ins AnyTypeOf<[AnySignlessInteger, Index, AnyFloat],
-                                 "integer/index/float type">:$input);
+  let arguments = (ins AnyType:$input);
   let results = (outs AnyStaticShapeTensor:$aggregate);
 
   let builders = [
     OpBuilder<(ins "Value":$element, "Type":$aggregateType),
     [{ build($_builder, $_state, aggregateType, element); }]>];
   let assemblyFormat = "$input attr-dict `:` type($aggregate)";
 
   let hasFolder = 1;

mlir/test/Dialect/Tensor/invalid.mlir

 func.func @invalid_splat(%v : f32) {
   // expected-error@+1 {{invalid kind of type specified}}
   tensor.splat %v : memref<8xf32>
   return
 }
 
 // -----
 
-func.func @invalid_splat(%v : vector<8xf32>) {
-  // expected-error@+1 {{must be integer/index/float type}}
-  %w = tensor.splat %v : tensor<8xvector<8xf32>>
-  return
-}
-
-// -----
-
 func.func @gather_empty_dims(
     %source : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
   // expected-error@+1 {{gather_dims must be non-empty}}
   %out = tensor.gather %source[%indices] gather_dims([]):
     (tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2xf32>
   return
 }