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.
}
}
- 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 {
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 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;
};
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) {
--- /dev/null
+! 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