[MLIR][tensor] generate default builder for FromElementsOp

[makslevental]

Summary

Removed builder is the same as default builder, with the added benefit that python bindings will be generated for the default builder.

[makslevental]

lint

[makslevental]

mlir/test/python/dialects/tensor.py

85

dead code

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

let description = [{
      [%d, %e, %f]]
   }];
 
   let arguments = (ins Variadic<AnyType>:$elements);
   let results = (outs AnyStaticShapeTensor:$result);
 
   let assemblyFormat = "$elements attr-dict `:` type($result)";
 
-  let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<(ins "Type":$resultType, "ValueRange":$elements)>,
     // Special case builder for when `elements` has size >=1.
     OpBuilder<(ins "ValueRange":$elements)>
   ];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

 //===----------------------------------------------------------------------===//
 
 void FromElementsOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "from_elements");
 }
 
 void FromElementsOp::build(OpBuilder &builder, OperationState &result,
-                           Type resultType, ValueRange elements) {
-  result.addOperands(elements);
-  result.addTypes(resultType);
-}
-
-void FromElementsOp::build(OpBuilder &builder, OperationState &result,
                            ValueRange elements) {
   assert(!elements.empty() && "expected at least one element");
   Type resultType = RankedTensorType::get(
       {static_cast<int64_t>(elements.size())}, elements.front().getType());
   build(builder, result, resultType, elements);
 }
 
 OpFoldResult FromElementsOp::fold(FoldAdaptor adaptor) {

mlir/test/python/dialects/tensor.py

 
 
 # CHECK-LABEL: TEST: testInferTypesInsertSlice
 @run
 def testInferTypesInsertSlice():
   with Context() as ctx, Location.unknown():
     module = Module.create()
     f32Type = F32Type.get()
-    indexType = IndexType.get()
     with InsertionPoint(module.body):
 
       @func.FuncOp.from_py_func(
           RankedTensorType.get((1, 1), f32Type),
           RankedTensorType.get((1, 1), f32Type))
       # CHECK: func @f
       # CHECK:      tensor.insert_slice %arg0 into %arg1[0, 0] [1, 1] [0, 0] :
       # CHECK-SAME:   tensor<1x1xf32> into tensor<1x1xf32>
       def f(source, dest):
-        c0 = arith.ConstantOp(indexType, 0)
-        c1 = arith.ConstantOp(indexType, 1)
         d0 = tensor.InsertSliceOp(source, dest, [], [], [],
                                   DenseI64ArrayAttr.get([0, 0]),
                                   DenseI64ArrayAttr.get([1, 1]),
                                   DenseI64ArrayAttr.get([0, 0]))
         return [d0.result]
 
   print(module)
+
+
+# CHECK-LABEL: TEST: testFromElementsOp
+@run
+def testFromElementsOp():
+  with Context() as ctx, Location.unknown():
+    module = Module.create()
+    f32 = F32Type.get()
+    with InsertionPoint(module.body):
+      @func.FuncOp.from_py_func()
+      def default_builder():
+        c0 = arith.ConstantOp(f32, 0.0)
+        # CHECK: %[[C0:.*]] = "arith.constant"() {value = 0.000000e+00 : f32} : () -> f32
+        print(c0)
+        c1 = arith.ConstantOp(f32, 1.0)
+        # CHECK: %[[C1:.*]] = "arith.constant"() {value = 1.000000e+00 : f32} : () -> f32
+        print(c1)
+
+        t = tensor.FromElementsOp(RankedTensorType.get((2,), f32), [c0, c1])
+        # CHECK: %{{.*}} = "tensor.from_elements"(%[[C0]], %[[C1]]) : (f32, f32) -> tensor<2xf32>
+        print(t)
+
+        t = tensor.FromElementsOp(RankedTensorType.get((2, 1), f32), [c0, c1])
+        # CHECK: %{{.*}} = "tensor.from_elements"(%[[C0]], %[[C1]]) : (f32, f32) -> tensor<2x1xf32>
+        print(t)
+
+        t = tensor.FromElementsOp(RankedTensorType.get((1, 2), f32), [c0, c1])
+        # CHECK: %{{.*}} = "tensor.from_elements"(%[[C0]], %[[C1]]) : (f32, f32) -> tensor<1x2xf32>
+        print(t)