[flang] Represent (parentheses around derived types)

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.

Differential Revision: https://reviews.llvm.org/D110355
This commit is contained in:
peter klausler 2021-09-22 16:49:09 -07:00
parent fbaf367217
commit f6ecea1a35
4 changed files with 60 additions and 6 deletions

View File

@ -116,8 +116,10 @@ class Operation {
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.
@ -172,7 +174,9 @@ public:
}
}
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 {
@ -222,6 +226,17 @@ struct Parentheses : public Operation<Parentheses<A>, 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;
@ -730,7 +745,7 @@ 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;
};

View File

@ -107,6 +107,10 @@ template <typename A> int ExpressionBase<A>::Rank() const {
derived().u);
}
DynamicType Parentheses<SomeDerived>::GetType() const {
return left().GetType().value();
}
// Equality testing
bool ImpliedDoIndex::operator==(const ImpliedDoIndex &that) const {

View File

@ -35,9 +35,10 @@ 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) {

View File

@ -0,0 +1,34 @@
! 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