[flang] Fix Symbol::Rank for ProcEntityDetails

[klausler]

Summary

When a procedure pointer or procedure dummy argument has a
defined interface, the rank of the pointer (or dummy) is the
rank of the interface.

Also tweak code discovered in shape analysis when investigating
this problam so that it returns a vector of emptied extents rather
than std::nullopt when the extents are not scope-invariant, so that
the rank can at least be known.

flang/include/flang/Semantics/symbol.h

return std::visit(
             },
             [](const GenericDetails &) {
               return 0; /*TODO*/
             },
             [](const ProcBindingDetails &x) { return x.symbol().Rank(); },
             [](const UseDetails &x) { return x.symbol().Rank(); },
             [](const HostAssocDetails &x) { return x.symbol().Rank(); },
             [](const ObjectEntityDetails &oed) { return oed.shape().Rank(); },
+            [](const ProcEntityDetails &ped) {
+              const Symbol *iface{ped.interface().symbol()};
+              return iface ? iface->Rank() : 0;
+            },
             [](const AssocEntityDetails &aed) {
               if (const auto &expr{aed.expr()}) {
                 if (auto assocRank{aed.rank()}) {
                   return *assocRank;
                 } else {
                   return expr->Rank();
                 }
               } else {

flang/lib/Evaluate/shape.cpp

return std::visit(
           [&](const semantics::SubprogramDetails &subp) -> Result {
             if (subp.isFunction()) {
               auto resultShape{(*this)(subp.result())};
               if (resultShape && !useResultSymbolShape_) {
                 // Ensure the shape is constant. Otherwise, it may be referring
                 // to symbols that belong to the subroutine scope and are
                 // meaningless on the caller side without the related call
                 // expression.
-                for (auto extent : *resultShape) {
-                  if (extent && !IsConstantExpr(*extent)) {
-                    return std::nullopt;
+                for (auto &extent : *resultShape) {
+                  if (extent && !IsActuallyConstant(*extent)) {
+                    extent.reset();
                   }
                 }
               }
               return resultShape;
             } else {
               return Result{};
             }
           },

flang/test/Evaluate/rewrite01.f90

subroutine size_test(x, n, m)
   print *, size(returns_array(n, m), dim=1)
   !CHECK: PRINT *, size(returns_array_2(m))
   print *, size(returns_array_2(m))
   !CHECK: PRINT *, 42_8
   print *, size(returns_array_3(), kind=8)
 end subroutine
 
 subroutine shape_test(x, n, m)
+  abstract interface
+    function foo(n)
+      integer, intent(in) :: n
+      real, pointer :: foo(:,:)
+    end function
+  end interface
+  procedure(foo), pointer :: pf
   integer :: x(n, m)
   !CHECK: PRINT *, [INTEGER(4)::int(size(x,dim=1,kind=8),kind=4),int(size(x,dim=2,kind=8),kind=4)]
   print *, shape(x)
   !CHECK: PRINT *, shape(returns_array(n,m))
   print *, shape(returns_array(n, m))
   !CHECK: PRINT *, shape(returns_array_2(m))
   print *, shape(returns_array_2(m))
   !CHECK: PRINT *, [INTEGER(8)::42_8]
   print *, shape(returns_array_3(), kind=8)
+  !CHECK: PRINT *, 2_4
+  print *, rank(pf(1))
 end subroutine
 
 subroutine lbound_test(x, n, m)
   integer :: x(n, m)
   integer :: y(0:n, 0:m) ! LBOUND could be 1 if n or m are < 0
   type t
     real, pointer :: p(:, :)
   end type