[flang] Emit warnings when results of folding some integer intrinsics overflow

[klausler]

Summary

When the compile-time result value of a reference to an integer-valued intrinsic
function COUNT, ICHAR, IACHAR, INDEX, SCAN, or VERIFY cannot be represented in
the selected result kind, emit a warning.

[klausler]

folding05.f90 is not actually a binary file, but it does contain a NUL character that makes "diff" think that it is one. The diff on the file is:

diff --git a/flang/test/Evaluate/folding05.f90 b/flang/test/Evaluate/folding05.f90
index 3be3904ccab5..f876a56691b8 100644
--- a/flang/test/Evaluate/folding05.f90
+++ b/flang/test/Evaluate/folding05.f90
@@ -33,12 +33,14 @@ module character_intrinsic_tests

   logical, parameter :: test_ichar1 = char(ichar("a")).EQ."a"
   logical, parameter :: test_ichar2 = ichar(char(255)).EQ.255
+  !WARN: warning: Result of intrinsic function 'ichar' (255) overflows its result type
   logical, parameter :: test_ichar3 = ichar(char(-1_1), 1).EQ.-1_1
   logical, parameter :: test_ichar4 = ichar(char(2147483647_4, 4), 4).EQ.2147483647_4
   logical, parameter :: test_ichar5 = ichar(char(4294967295_8, 4), 8).EQ.4294967295_8
   logical, parameter :: test_ichar6 = ichar(char(4294967296_8, 4), 8).EQ.0_8
   logical, parameter :: test_iachar1 = achar(iachar("a")).EQ."a"
   logical, parameter :: test_iachar2 = iachar(achar(22)).EQ.22
+  !WARN: warning: Result of intrinsic function 'ichar' (2147483649) overflows its result type
   logical, parameter :: test_iachar3 = ichar(char(-2147483647_4, 4), 4).EQ.(-2147483647_4)
   logical, parameter :: test_iachar5 = ichar(char(65535_4, 2), 4).EQ.65535_4
   logical, parameter :: test_iachar6 = ichar(char(65536_4, 2), 4).EQ.0_4

flang/lib/Evaluate/fold-integer.cpp

 static Expr<T> FoldCount(FoldingContext &context, FunctionRef<T> &&ref) {
   static_assert(T::category == TypeCategory::Integer);
   ActualArguments &arg{ref.arguments()};
   if (const Constant<LogicalResult> *mask{arg.empty()
               ? nullptr
               : Folder<LogicalResult>{context}.Folding(arg[0])}) {
     std::optional<int> dim;
     if (CheckReductionDIM(dim, context, arg, 1, mask->Rank())) {
-      auto accumulator{[&](Scalar<T> &element, const ConstantSubscripts &at) {
+      bool overflow{false};
+      auto accumulator{
+          [&mask, &overflow](Scalar<T> &element, const ConstantSubscripts &at) {
             if (mask->At(at).IsTrue()) {
-          element = element.AddSigned(Scalar<T>{1}).value;
+              auto incremented{element.AddSigned(Scalar<T>{1})};
+              overflow |= incremented.overflow;
+              element = incremented.value;
             }
           }};
-      return Expr<T>{DoReduction<T>(*mask, dim, Scalar<T>{}, accumulator)};
+      Constant<T> result{DoReduction<T>(*mask, dim, Scalar<T>{}, accumulator)};
+      if (overflow) {
+        context.messages().Say(
+            "Result of intrinsic function COUNT overflows its result type"_warn_en_US);
+      }
+      return Expr<T>{std::move(result)};
     }
   }
   return Expr<T>{std::move(ref)};
 }
 
 // FINDLOC(), MAXLOC(), & MINLOC()
 enum class WhichLocation { Findloc, Maxloc, Minloc };
 template <WhichLocation WHICH> class LocationHelper {
Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Integer, KIND>> &&funcRef) {
   using T = Type<TypeCategory::Integer, KIND>;
   using Int4 = Type<TypeCategory::Integer, 4>;
   ActualArguments &args{funcRef.arguments()};
   auto *intrinsic{std::get_if<SpecificIntrinsic>(&funcRef.proc().u)};
   CHECK(intrinsic);
   std::string name{intrinsic->name};
+  auto FromInt64{[&name, &context](std::int64_t n) {
+    Scalar<T> result{n};
+    if (result.ToInt64() != n) {
+      context.messages().Say(
+          "Result of intrinsic function '%s' (%jd) overflows its result type"_warn_en_US,
+          name, std::intmax_t{n});
+    }
+    return result;
+  }};
   if (name == "abs") { // incl. babs, iiabs, jiaabs, & kiabs
     return FoldElementalIntrinsic<T, T>(context, std::move(funcRef),
         ScalarFunc<T, T>([&context](const Scalar<T> &i) -> Scalar<T> {
           typename Scalar<T>::ValueWithOverflow j{i.ABS()};
           if (j.overflow) {
             context.messages().Say(
                 "abs(integer(kind=%d)) folding overflowed"_warn_en_US, KIND);
           }
if (name == "abs") { // incl. babs, iiabs, jiaabs, & kiabs
     if (auto len{ToInt64(someChar->LEN())}) {
       if (len.value() != 1) {
         // Do not die, this was not checked before
         context.messages().Say(
             "Character in intrinsic function %s must have length one"_warn_en_US,
             name);
       } else {
         return common::visit(
-            [&funcRef, &context](const auto &str) -> Expr<T> {
+            [&funcRef, &name, &context, &FromInt64](
+                const auto &str) -> Expr<T> {
               using Char = typename std::decay_t<decltype(str)>::Result;
               return FoldElementalIntrinsic<T, Char>(context,
                   std::move(funcRef),
-                  ScalarFunc<T, Char>([](const Scalar<Char> &c) {
-                    return Scalar<T>{CharacterUtils<Char::kind>::ICHAR(c)};
+                  ScalarFunc<T, Char>([&FromInt64](const Scalar<Char> &c) {
+                    return FromInt64(CharacterUtils<Char::kind>::ICHAR(c));
                   }));
             },
             someChar->u);
       }
     }
   } else if (name == "iand" || name == "ior" || name == "ieor") {
     auto fptr{&Scalar<T>::IAND};
     if (name == "iand") { // done in fptr declaration
if (name == "abs") { // incl. babs, iiabs, jiaabs, & kiabs
     if (auto *charExpr{UnwrapExpr<Expr<SomeCharacter>>(args[0])}) {
       return common::visit(
           [&](const auto &kch) -> Expr<T> {
             using TC = typename std::decay_t<decltype(kch)>::Result;
             if (UnwrapExpr<Expr<SomeLogical>>(args[2])) { // BACK=
               return FoldElementalIntrinsic<T, TC, TC, LogicalResult>(context,
                   std::move(funcRef),
                   ScalarFunc<T, TC, TC, LogicalResult>{
-                      [&name](const Scalar<TC> &str, const Scalar<TC> &other,
-                          const Scalar<LogicalResult> &back) -> Scalar<T> {
-                        return name == "index"
+                      [&name, &FromInt64](const Scalar<TC> &str,
+                          const Scalar<TC> &other,
+                          const Scalar<LogicalResult> &back) {
+                        return FromInt64(name == "index"
                                 ? CharacterUtils<TC::kind>::INDEX(
                                       str, other, back.IsTrue())
-                            : name == "scan" ? CharacterUtils<TC::kind>::SCAN(
-                                                   str, other, back.IsTrue())
-                                             : CharacterUtils<TC::kind>::VERIFY(
-                                                   str, other, back.IsTrue());
+                                : name == "scan"
+                                ? CharacterUtils<TC::kind>::SCAN(
+                                      str, other, back.IsTrue()));
                       }});
             } else {
               return FoldElementalIntrinsic<T, TC, TC>(context,
                   std::move(funcRef),
                   ScalarFunc<T, TC, TC>{
-                      [&name](const Scalar<TC> &str,
-                          const Scalar<TC> &other) -> Scalar<T> {
-                        return name == "index"
+                      [&name, &FromInt64](
+                          const Scalar<TC> &str, const Scalar<TC> &other) {
+                        return FromInt64(name == "index"
                                 ? CharacterUtils<TC::kind>::INDEX(str, other)
                                 : name == "scan"
                                 ? CharacterUtils<TC::kind>::SCAN(str, other)
-                            : CharacterUtils<TC::kind>::VERIFY(str, other);
+                                : CharacterUtils<TC::kind>::VERIFY(str, other));
                       }});
             }
           },
           charExpr->u);
     } else {
       DIE("first argument must be CHARACTER");
     }
   } else if (name == "int") {
if (auto *charExpr{UnwrapExpr<Expr<SomeCharacter>>(args[0])}) {
       DIE("len() argument must be of character type");
     }
   } else if (name == "len_trim") {
     if (auto *charExpr{UnwrapExpr<Expr<SomeCharacter>>(args[0])}) {
       return common::visit(
           [&](const auto &kch) -> Expr<T> {
             using TC = typename std::decay_t<decltype(kch)>::Result;
             return FoldElementalIntrinsic<T, TC>(context, std::move(funcRef),
-                ScalarFunc<T, TC>{[](const Scalar<TC> &str) -> Scalar<T> {
-                  return CharacterUtils<TC::kind>::LEN_TRIM(str);
+                ScalarFunc<T, TC>{[&FromInt64](const Scalar<TC> &str) {
+                  return FromInt64(CharacterUtils<TC::kind>::LEN_TRIM(str));
                 }});
           },
           charExpr->u);
     } else {
       DIE("len_trim() argument must be of character type");
     }
   } else if (name == "maskl" || name == "maskr") {
     // Argument can be of any kind but value has to be smaller than BIT_SIZE.