[flang] Implement constant folding for the NOT intrinsic

[PeteSteinfeld]

Summary

I implemented constant folding for the NOT intrinsic and added some tests.

[klausler]

LGTM & thanks!

flang/lib/Evaluate/fold-integer.cpp

return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef),
             [](FoldingContext &context, const Scalar<T> &x,
                 const Scalar<T> &y) -> Scalar<T> {
               auto result{x.MODULO(y)};
               if (result.overflow) {
                 context.messages().Say("modulo() folding overflowed"_en_US);
               }
               return result.value;
             }));
+  } else if (name == "not") {
+    return FoldElementalIntrinsic<T, T>(
+        context, std::move(funcRef), &Scalar<T>::NOT);
   } else if (name == "precision") {
     if (const auto *cx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
       return Expr<T>{std::visit(
           [](const auto &kx) {
             return Scalar<ResultType<decltype(kx)>>::PRECISION;
           },
           cx->u)};
     } else if (const auto *cx{UnwrapExpr<Expr<SomeComplex>>(args[0])}) {
if (auto info{
       }
     }
   } else if (name == "ubound") {
     return UBOUND(context, std::move(funcRef));
   }
   // TODO:
   // cshift, dot_product, eoshift,
   // findloc, iall, iany, iparity, ibits, image_status, ishftc,
-  // matmul, maxloc, minloc, not, pack, product, reduce,
+  // matmul, maxloc, minloc, pack, product, reduce,
   // sign, spread, sum, transfer, transpose, unpack
   return Expr<T>{std::move(funcRef)};
 }
 
 // Substitutes a bare type parameter reference with its value if it has one now
 // in an instantiation.  Bare LEN type parameters are substituted only when
 // the known value is constant.
 Expr<TypeParamInquiry::Result> FoldOperation(

flang/test/Evaluate/folding01.f90

! Check integer intrinsic operation folding
   logical, parameter :: test_min_c_2 = res_min_c.EQ.exp_min
   logical, parameter :: test_min_c_3 = len(res_min_c).EQ.len(c3)
 
   integer, parameter :: x1a(*) = [1, 12, 3, 14]
   integer, parameter :: x2a(*) = [11, 2, 13, 4]
   logical, parameter :: test_max_a1 = all(max(x1a, x2a).EQ.[11, 12, 13, 14])
   logical, parameter :: test_min_a1 = all(min(x1a, x2a).EQ.[1, 2, 3, 4])
 
+  logical, parameter :: test_not_zero = not(0).EQ.-1
+  logical, parameter :: test_not_neg_one = not(-1).EQ.0
+  logical, parameter :: test_not_array = all(not([5, 6, 7]).EQ.[-6, -7, -8])
+ 
 end module