[flang] Represent (parentheses around derived types)

[klausler]

Summary

The strongly typed expression representation classes supported
a representation of parentheses only around intrinsic types
with specific kinds. Parentheses around derived type variables
must also be preserved so that expressions may be distinguished
from variables; this distinction matters for actual arguments &
construct associations.

flang/include/flang/Evaluate/expression.h

class Operation {
   // The extra final member is a dummy that allows a safe unused reference
   // to element 1 to arise indirectly in the definition of "right()" below
   // when the operation has but a single operand.
   using OperandTypes = std::tuple<OPERANDS..., std::monostate>;
 
 public:
   using Derived = DERIVED;
   using Result = RESULT;
-  static_assert(IsSpecificIntrinsicType<Result>);
   static constexpr std::size_t operands{sizeof...(OPERANDS)};
+  // Allow specific intrinsic types and Parentheses<SomeDerived>
+  static_assert(IsSpecificIntrinsicType<Result> ||
+      (operands == 1 && std::is_same_v<Result, SomeDerived>));
   template <int J> using Operand = std::tuple_element_t<J, OperandTypes>;
 
   // Unary operations wrap a single Expr with a CopyableIndirection.
   // Binary operations wrap a tuple of CopyableIndirections to Exprs.
 private:
   using Container = std::conditional_t<operands == 1,
       common::CopyableIndirection<Expr<Operand<0>>>,
       std::tuple<common::CopyableIndirection<Expr<OPERANDS>>...>>;
public:
   }
   std::conditional_t<(operands > 1), const Expr<Operand<1>> &, void>
   right() const {
     if constexpr (operands > 1) {
       return operand<1>();
     }
   }
 
-  static constexpr std::optional<DynamicType> GetType() {
+  static constexpr std::conditional_t<Result::category != TypeCategory::Derived,
+      std::optional<DynamicType>, void>
+  GetType() {
     return Result::GetType();
   }
   int Rank() const {
     int rank{left().Rank()};
     if constexpr (operands > 1) {
       return std::max(rank, right().Rank());
     } else {
       return rank;

 template <typename A>
 struct Parentheses : public Operation<Parentheses<A>, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Parentheses, A, A>;
   using Base::Base;
 };
 
+template <>
+struct Parentheses<SomeDerived>
+    : public Operation<Parentheses<SomeDerived>, SomeDerived, SomeDerived> {
+public:
+  using Result = SomeDerived;
+  using Operand = SomeDerived;
+  using Base = Operation<Parentheses, SomeDerived, SomeDerived>;
+  using Base::Base;
+  DynamicType GetType() const;
+};
+
 template <typename A> struct Negate : public Operation<Negate<A>, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Negate, A, A>;
   using Base::Base;
 };
 
 template <int KIND>

 };
 
 // An expression whose result has a derived type.
 template <> class Expr<SomeDerived> : public ExpressionBase<SomeDerived> {
 public:
   using Result = SomeDerived;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
   std::variant<Constant<Result>, ArrayConstructor<Result>, StructureConstructor,
-      Designator<Result>, FunctionRef<Result>>
+      Designator<Result>, FunctionRef<Result>, Parentheses<Result>>
       u;
 };
 
 // A polymorphic expression of known intrinsic type category, but dynamic
 // kind, represented as a discriminated union over Expr<Type<CAT, K>>
 // for each supported kind K in the category.
 template <TypeCategory CAT>
 class Expr<SomeKind<CAT>> : public ExpressionBase<SomeKind<CAT>> {

flang/lib/Evaluate/expression.cpp

return std::visit(
           return 0;
         } else {
           return x.Rank();
         }
       },
       derived().u);
 }
 
+DynamicType Parentheses<SomeDerived>::GetType() const {
+  return left().GetType().value();
+}
+
 // Equality testing
 
 bool ImpliedDoIndex::operator==(const ImpliedDoIndex &that) const {
   return name == that.name;
 }
 
 template <typename T>
 bool ImpliedDo<T>::operator==(const ImpliedDo<T> &that) const {

flang/lib/Evaluate/tools.cpp

 std::optional<Expr<SomeType>> AsGenericExpr(const Symbol &symbol) {
   return AsGenericExpr(DataRef{symbol});
 }
 
 Expr<SomeType> Parenthesize(Expr<SomeType> &&expr) {
   return std::visit(
       [&](auto &&x) {
         using T = std::decay_t<decltype(x)>;
-        if constexpr (common::HasMember<T, TypelessExpression> ||
-            std::is_same_v<T, Expr<SomeDerived>>) {
-          return expr; // no parentheses around typeless or derived type
+        if constexpr (common::HasMember<T, TypelessExpression>) {
+          return expr; // no parentheses around typeless
+        } else if constexpr (std::is_same_v<T, Expr<SomeDerived>>) {
+          return AsGenericExpr(Parentheses<SomeDerived>{std::move(x)});
         } else {
           return std::visit(
               [](auto &&y) {
                 using T = ResultType<decltype(y)>;
                 return AsGenericExpr(Parentheses<T>{std::move(y)});
               },
               std::move(x.u));
         }

flang/test/Evaluate/expr01.f90

+! RUN: %flang_fc1 -fdebug-unparse %s 2>&1 | FileCheck %s
+! Ensures that parentheses are preserved with derived types
+module m
+  type :: t
+    integer :: n
+  end type
+ contains
+  subroutine sub(x)
+    type(t), intent(in) :: x
+  end subroutine
+  function f(m)
+    type(t), pointer :: f
+    integer, intent(in) :: m
+    type(t), save, target :: res
+    res%n = m
+    f => res
+  end function
+  subroutine test
+    type(t) :: x
+    x = t(1)
+    !CHECK: CALL sub(t(n=1_4))
+    call sub(t(1))
+    !CHECK: CALL sub((t(n=1_4)))
+    call sub((t(1)))
+    !CHECK: CALL sub(x)
+    call sub(x)
+    !CHECK: CALL sub((x))
+    call sub((x))
+    !CHECK: CALL sub(f(2_4))
+    call sub(f(2))
+    !CHECK: CALL sub((f(2_4)))
+    call sub((f(2)))
+  end subroutine
+end module