[flang] Fix an assertion error when a BOZ literal is used as a relational operator

[PeteSteinfeld]

Summary

Expressions like iVar==z'fe' were causing an assertion error because the Relate()
function in Evaluate/tools.cpp that processes relational operators didn't
deal with BOZ literals, which are typeless. I fixed this by checking to see if
the operands are BOZ literals. If so, I convert them to integers with default
kind. To get the default kind, I needed to pass a new parameter to Relate().

I also added a test to resolve63.f90 that triggers the problem.

Also, when I ran the latest clang-format on Evaluate/tools.cpp, it
reformatted a comment which was coincidentally related to BOZ literals. This
change is unrelated to the rest of the code.

[tskeith]

flang/lib/Evaluate/tools.cpp

486

Evaluate is not supposed to have link-time dependencies on Semantics (I think) so calling GetDefaultKind is bad here. Instead of passing in SemanticsContext, I think you could pass in (a reference to) the common::IntrinsicTypeDefaultKinds that is stored in SemanticsContext.

492

I get a warning from clang 9 that this call to std::move and the one on line 485 are not needed.

[PeteSteinfeld]

I discovered that there was another dereference of the nullopt type of a BOZ
literal. In order to catch both dereferences, I convert all BOZ literals that
are operands in a relational expression to INTEGERs. In practice, this means
that comparisons to numeric types do not produce errors while a comparison to a
CHARACTER or LOGICAL operand does produce an error. This behavior matches most
of the other compilers I tested. The exception is IBM's compiler, which allows
comparisons between BOZ literals and CHARACTER operands.

[PeteSteinfeld]

I handled comparing BOZ literals to REAL operands in the same way as the rest
of the compiler. I also now handle comparing a BOZ literal to another BOZ
literal.

[klausler]

This comment was removed by klausler.

flang/include/flang/Evaluate/tools.h

extern template std::optional<Expr<SomeType>> NumericOperation<Subtract>(
     parser::ContextualMessages &, Expr<SomeType> &&, Expr<SomeType> &&,
     int defaultRealKind);
 
 std::optional<Expr<SomeType>> Negation(
     parser::ContextualMessages &, Expr<SomeType> &&);
 
 // Given two expressions of arbitrary type, try to combine them with a
 // relational operator (e.g., .LT.), possibly with data type conversion.
-std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &,
-    RelationalOperator, Expr<SomeType> &&, Expr<SomeType> &&);
+std::optional<Expr<LogicalResult>> Relate(semantics::SemanticsContext &context,
+    parser::ContextualMessages &, RelationalOperator, Expr<SomeType> &&,
+    Expr<SomeType> &&);
 
 template <int K>
 Expr<Type<TypeCategory::Logical, K>> LogicalNegation(
     Expr<Type<TypeCategory::Logical, K>> &&x) {
   return AsExpr(Not<K>{std::move(x)});
 }
 
 Expr<SomeLogical> LogicalNegation(Expr<SomeLogical> &&);

 
 // Utilities for attaching the location of the declaration of a symbol
 // of interest to a message, if both pointers are non-null.  Handles
 // the case of USE association gracefully.
 parser::Message *AttachDeclaration(parser::Message &, const Symbol &);
 parser::Message *AttachDeclaration(parser::Message *, const Symbol &);
 template <typename MESSAGES, typename... A>
 parser::Message *SayWithDeclaration(
-    MESSAGES &messages, const Symbol &symbol, A &&... x) {
+    MESSAGES &messages, const Symbol &symbol, A &&...x) {
   return AttachDeclaration(messages.Say(std::forward<A>(x)...), symbol);
 }
 
 // Check for references to impure procedures; returns the name
 // of one to complain about, if any exist.
 std::optional<std::string> FindImpureCall(
     const IntrinsicProcTable &, const Expr<SomeType> &);
 std::optional<std::string> FindImpureCall(

flang/lib/Evaluate/tools.cpp

Expr<LogicalResult> PromoteAndRelate(
     RelationalOperator opr, Expr<SomeKind<CAT>> &&x, Expr<SomeKind<CAT>> &&y) {
   return std::visit(
       [=](auto &&xy) {
         return PackageRelation(opr, std::move(xy[0]), std::move(xy[1]));
       },
       AsSameKindExprs(std::move(x), std::move(y)));
 }
 
-std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &messages,
-    RelationalOperator opr, Expr<SomeType> &&x, Expr<SomeType> &&y) {
+std::optional<Expr<LogicalResult>> Relate(semantics::SemanticsContext &context,
+    parser::ContextualMessages &messages, RelationalOperator opr,
+    Expr<SomeType> &&x, Expr<SomeType> &&y) {
+  // Convert any BOZ literal operands to integers
+  if (auto *boz{std::get_if<BOZLiteralConstant>(&x.u)}) {
+    return Relate(context, messages, opr,
+        std::move(Expr<SomeType>{ConvertToKind<TypeCategory::Integer>(
+            context.GetDefaultKind(TypeCategory::Integer), std::move(*boz))}),
+        std::move(y));
+  } else if (auto *boz{std::get_if<BOZLiteralConstant>(&y.u)}) {
+    Expr<SomeType> yExpr{ConvertToKind<TypeCategory::Integer>(
+        context.GetDefaultKind(TypeCategory::Integer), std::move(*boz))};
+    return Relate(context, messages, opr, std::move(x),
+        std::move(Expr<SomeType>{ConvertToKind<TypeCategory::Integer>(
+            context.GetDefaultKind(TypeCategory::Integer), std::move(*boz))}));
+  } else {
     return std::visit(
         common::visitors{
             [=](Expr<SomeInteger> &&ix,
                 Expr<SomeInteger> &&iy) -> std::optional<Expr<LogicalResult>> {
               return PromoteAndRelate(opr, std::move(ix), std::move(iy));
             },
             [=](Expr<SomeReal> &&rx,
                 Expr<SomeReal> &&ry) -> std::optional<Expr<LogicalResult>> {
               return PromoteAndRelate(opr, std::move(rx), std::move(ry));
             },
             [&](Expr<SomeReal> &&rx, Expr<SomeInteger> &&iy) {
-            return Relate(messages, opr, std::move(x),
+              return Relate(context, messages, opr, std::move(x),
                   AsGenericExpr(ConvertTo(rx, std::move(iy))));
             },
             [&](Expr<SomeInteger> &&ix, Expr<SomeReal> &&ry) {
-            return Relate(messages, opr,
+              return Relate(context, messages, opr,
                   AsGenericExpr(ConvertTo(ry, std::move(ix))), std::move(y));
             },
             [&](Expr<SomeComplex> &&zx,
                 Expr<SomeComplex> &&zy) -> std::optional<Expr<LogicalResult>> {
               if (opr != RelationalOperator::EQ &&
                   opr != RelationalOperator::NE) {
                 messages.Say(
                     "COMPLEX data may be compared only for equality"_err_en_US);
               } else {
-              auto rr{Relate(messages, opr,
+                auto rr{Relate(context, messages, opr,
                     AsGenericExpr(GetComplexPart(zx, false)),
                     AsGenericExpr(GetComplexPart(zy, false)))};
-              auto ri{
-                  Relate(messages, opr, AsGenericExpr(GetComplexPart(zx, true)),
-                      AsGenericExpr(GetComplexPart(zy, true)))};
+                auto ri{Relate(context, messages, opr,
+                    AsGenericExpr(GetComplexPart(zx, true)),
                 if (auto parts{
                         common::AllPresent(std::move(rr), std::move(ri))}) {
                   // (a,b)==(c,d) -> (a==c) .AND. (b==d)
                   // (a,b)/=(c,d) -> (a/=c) .OR. (b/=d)
                   LogicalOperator combine{opr == RelationalOperator::EQ
                           ? LogicalOperator::And
                           : LogicalOperator::Or};
                   return Expr<LogicalResult>{
                       LogicalOperation<LogicalResult::kind>{combine,
                           std::get<0>(std::move(*parts)),
                           std::get<1>(std::move(*parts))}};
                 }
               }
               return std::nullopt;
             },
             [&](Expr<SomeComplex> &&zx, Expr<SomeInteger> &&iy) {
-            return Relate(messages, opr, std::move(x),
+              return Relate(context, messages, opr, std::move(x),
                   AsGenericExpr(ConvertTo(zx, std::move(iy))));
             },
             [&](Expr<SomeComplex> &&zx, Expr<SomeReal> &&ry) {
-            return Relate(messages, opr, std::move(x),
+              return Relate(context, messages, opr, std::move(x),
                   AsGenericExpr(ConvertTo(zx, std::move(ry))));
             },
             [&](Expr<SomeInteger> &&ix, Expr<SomeComplex> &&zy) {
-            return Relate(messages, opr,
+              return Relate(context, messages, opr,
                   AsGenericExpr(ConvertTo(zy, std::move(ix))), std::move(y));
             },
             [&](Expr<SomeReal> &&rx, Expr<SomeComplex> &&zy) {
-            return Relate(messages, opr,
+              return Relate(context, messages, opr,
                   AsGenericExpr(ConvertTo(zy, std::move(rx))), std::move(y));
             },
             [&](Expr<SomeCharacter> &&cx, Expr<SomeCharacter> &&cy) {
               return std::visit(
                   [&](auto &&cxk,
                       auto &&cyk) -> std::optional<Expr<LogicalResult>> {
                     using Ty = ResultType<decltype(cxk)>;
-                  if constexpr (std::is_same_v<Ty, ResultType<decltype(cyk)>>) {
-                    return PackageRelation(opr, std::move(cxk), std::move(cyk));
+                    if constexpr (std::is_same_v<Ty,
+                                      ResultType<decltype(cyk)>>) {
+                      return PackageRelation(
+                          opr, std::move(cxk), std::move(cyk));
                     } else {
                       messages.Say(
                           "CHARACTER operands do not have same KIND"_err_en_US);
                       return std::nullopt;
                     }
                   },
                   std::move(cx.u), std::move(cy.u));
             },
             // Default case
             [&](auto &&, auto &&) {
               DIE("invalid types for relational operator");
               return std::optional<Expr<LogicalResult>>{};
             },
         },
         std::move(x.u), std::move(y.u));
   }
+}
 
 Expr<SomeLogical> BinaryLogicalOperation(
     LogicalOperator opr, Expr<SomeLogical> &&x, Expr<SomeLogical> &&y) {
   CHECK(opr != LogicalOperator::Not);
   return std::visit(
       [=](auto &&xy) {
         using Ty = ResultType<decltype(xy[0])>;
         return Expr<SomeLogical>{BinaryLogicalOperation<Ty::kind>(
return std::visit(
       std::move(x.u));
 }
 
 std::optional<Expr<SomeType>> ConvertToType(
     const DynamicType &type, Expr<SomeType> &&x) {
   switch (type.category()) {
   case TypeCategory::Integer:
     if (auto *boz{std::get_if<BOZLiteralConstant>(&x.u)}) {
-      // Extension to C7109: allow BOZ literals to appear in integer contexts
-      // when the type is unambiguous.
+      // Extension to C7109: allow BOZ literals to appear in integer
+      // contexts when the type is unambiguous.
       return Expr<SomeType>{
           ConvertToKind<TypeCategory::Integer>(type.kind(), std::move(*boz))};
     }
     return ConvertToNumeric<TypeCategory::Integer>(type.kind(), std::move(x));
   case TypeCategory::Real:
     if (auto *boz{std::get_if<BOZLiteralConstant>(&x.u)}) {
       return Expr<SomeType>{
           ConvertToKind<TypeCategory::Real>(type.kind(), std::move(*boz))};

flang/lib/Semantics/expression.cpp

 MaybeExpr RelationHelper(ExpressionAnalyzer &context, RelationalOperator opr,
     const parser::Expr::IntrinsicBinary &x) {
   ArgumentAnalyzer analyzer{context};
   analyzer.Analyze(std::get<0>(x.t));
   analyzer.Analyze(std::get<1>(x.t));
   if (analyzer.fatalErrors()) {
     return std::nullopt;
   } else if (analyzer.IsIntrinsicRelational(opr)) {
-    return AsMaybeExpr(Relate(context.GetContextualMessages(), opr,
+    return AsMaybeExpr(
+        Relate(context.context(), context.GetContextualMessages(), opr,
             analyzer.MoveExpr(0), analyzer.MoveExpr(1)));
   } else {
     return analyzer.TryDefinedOp(opr,
         "Operands of %s must have comparable types; have %s and %s"_err_en_US);
   }
 }
 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::LT &x) {
   return RelationHelper(*this, RelationalOperator::LT, x);

flang/test/Semantics/resolve63.f90

module m1
   interface operator(.not.)
     logical function not_r(x)
       real, intent(in) :: x
     end
   end interface
   type(t) :: x, y
   real :: r
   logical :: l
+  integer :: iVar
 contains
   subroutine test_relational()
     l = x == y  !OK
     l = x .eq. y  !OK
+    l = x .eq. y  !OK
+    l = iVar == z'fe' !OK
+    l = z'fe' == iVar !OK
     !ERROR: No intrinsic or user-defined OPERATOR(==) matches operand types TYPE(t) and REAL(4)
     l = x == r
   end
   subroutine test_numeric()
     l = x + r  !OK
     !ERROR: No intrinsic or user-defined OPERATOR(+) matches operand types REAL(4) and TYPE(t)
     l = r + x
   end