[flang][hlfir] fix regression in inline elementals

[tblah]

Summary

InlineElementals created a regression when inlining elemental
expressions where the type of the result of the hlfir.apply does not
match the hlfir.yield.

This patch ensures the pass doesn't match in these cases, fixing the
regression.

It isn't clear to me what the /right/ solution is:

• Is it actually valid for the hlfir.apply to have a different type (even just different array bounds?). Should this be enforced in the verifier?
• Inserting a convert if these types don't match doesn't work because fir.convert doesn't know how to convert a hlfir.expr. Should this be added?

Test case is from @vzakhari

[jeanPerier]

Thanks, LGTM to be safe, but I agree with your points, this should not have happened in the first place. It looks the issue is not with the hlfir.apply itself, but the hlfir.elemental that has a "different" element type from its hlfir.yield_element:

%23 = hlfir.elemental %22 typeparams %c6 : (!fir.shape<3>, index) -> !hlfir.expr<?x?x?x!fir.char<1,?>> {
^bb0(%arg0: index, %arg1: index, %arg2: index):
  //.....
  %42 = hlfir.concat %40, %41 len %c6 : (!fir.ref<!fir.char<1,5>>, !fir.ref<!fir.char<1>>, index) -> !hlfir.expr<!fir.char<1,6>>
  hlfir.yield_element %42 : !hlfir.expr<!fir.char<1,6>>
}

Typical character length issue. I will try to fix lowering and add a verifier for the hlfir.elemental.

Inserting a convert if these types don't match doesn't work because fir.convert doesn't know how to convert a hlfir.expr. Should this be added?

I would stay away from this right now because this would likely imply creating a copy of potentially big values.

[vzakhari]

Thank you for the change, @tblah!

flang/lib/Optimizer/HLFIR/Transforms/InlineElementals.cpp

getTwoUses(hlfir::ElementalOp elemental) {
   hlfir::DestroyOp destroy;
   for (mlir::Operation *user : users)
     mlir::TypeSwitch<mlir::Operation *, void>(user)
         .Case([&](hlfir::ApplyOp op) { apply = op; })
         .Case([&](hlfir::DestroyOp op) { destroy = op; });
 
   if (!apply || !destroy)
     return std::nullopt;
+
+  // we can't inline if the return type of the yield doesn't match the return
+  // type of the apply
+  auto yield = mlir::dyn_cast_or_null<hlfir::YieldElementOp>(
+      elemental.getRegion().back().back());
+  assert(yield && "hlfir.elemental should always end with a yield");
+  if (apply.getResult().getType() != yield.getElementValue().getType())
+    return std::nullopt;
+
   return std::pair{apply, destroy};
 }
 
 namespace {
 class InlineElementalConversion
     : public mlir::OpRewritePattern<hlfir::ElementalOp> {
 public:
   using mlir::OpRewritePattern<hlfir::ElementalOp>::OpRewritePattern;

flang/test/HLFIR/inline-elemental.f90

+! RUN: %flang_fc1 -emit-obj -flang-experimental-hlfir -o /dev/null %s
+
+! Regression test: ensure we can compile this without crashing
+! this results in a hlfir.elemental with mismatched types in the hlfir.apply
+! and hlfir.yield
+subroutine test
+  interface
+    function func(i,j,k)
+      character(5),allocatable :: func(:,:,:)
+    end function func
+  end interface
+  character(13),allocatable :: a(:,:,:)
+  print *, (func(2,5,3)//reshape([(char(ichar('a')+n),n=1,2*5*3)], &
+    & [2,5,3]))
+end subroutine test