[mlir] return nullopt for getNeutralElement

[python3kgae]

Summary

Fixes 60210 https://github.com/llvm/llvm-project/issues/60210

Crash for return Attribute instead of nullopt.

[python3kgae]

rebase.

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

if (auto floatType = resultType.dyn_cast<FloatType>()) {
     if (isa<arith::MulFOp>(op))
       return b.getFloatAttr(resultType, llvm::APFloat(semantic, 1));
     if (isa<arith::MaxFOp>(op))
       return b.getFloatAttr(resultType,
                             llvm::APFloat::getInf(semantic, /*Negative=*/true));
     if (isa<arith::MinFOp>(op))
       return b.getFloatAttr(
           resultType, llvm::APFloat::getInf(semantic, /*Negative=*/false));
-    return Attribute();
+    return std::nullopt;
   }
   if (isa<arith::AddIOp, arith::OrIOp, arith::XOrIOp>(op))
     return b.getIntegerAttr(resultType, 0);
   if (isa<arith::AndIOp>(op))
     return b.getIntegerAttr(resultType, -1);
   if (isa<arith::MaxSIOp>(op))
     return b.getIntegerAttr(resultType, std::numeric_limits<int64_t>::min());
   if (isa<arith::MinSIOp>(op))
     return b.getIntegerAttr(resultType, std::numeric_limits<int64_t>::max());
   if (isa<arith::MulIOp>(op))
     return b.getIntegerAttr(resultType, 1);
   return std::nullopt;
 }
 
 } // namespace linalg
 } // namespace mlir

mlir/test/Dialect/Linalg/transform-tile-reduction.mlir

 transform.sequence failures(propagate) {
 ^bb0(%arg1: !pdl.operation):
   %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!pdl.operation) -> !pdl.operation
   // expected-error @below {{could not tile reduction}}
   %loop, %1, %2, %3 = transform.structured.tile_reduction_using_foreach_thread %0
     by num_threads = [5], tile_sizes = [3], mapping = [#gpu.thread<x>]
 
 }
+
+// -----
+
+#map = affine_map<(d0, d1) -> (d0, d1)>
+#map1 = affine_map<(d0, d1) -> (d0)>
+
+module {
+  func.func @fail_for_float_neutral(%arg0: tensor<?x?xf32>, %arg1: tensor<?xf32>) -> tensor<?xf32> {
+    // expected-error @below {{'linalg.generic' op Failed to get an identity value for the reduction operation.}}
+    // expected-note @below {{when applied to this op}}
+    %0 = linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "reduction"]} ins(%arg0 : tensor<?x?xf32>) outs(%arg1 : tensor<?xf32>) {
+    ^bb0(%in: f32, %out: f32):
+      %1 = llvm.fmul %in, %in  : f32
+      %2 = llvm.fadd %1, %out  : f32
+      linalg.yield %2 : f32
+    } -> tensor<?xf32>
+    return %0 : tensor<?xf32>
+  }
+  transform.sequence failures(propagate) {
+  ^bb0(%arg0: !pdl.operation):
+    %0 = transform.structured.match ops{["linalg.generic"]} in %arg0 : (!pdl.operation) -> !pdl.operation
+    // expected-error @below {{transform.structured.tile_reduction_using_scf failed to apply}}
+    %for_op, %fill_op, %split_linalg_op, %combining_linalg_op = transform.structured.tile_reduction_using_scf %0 by tile_sizes = [0, 5]
+  }
+}