From c0d3a67fac0918d45797bb2b385ed8c063ed318e Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Fri, 17 Aug 2018 15:38:37 -0700
Subject: [PATCH] [flang] complex extraction of operator classes

Original-commit: flang-compiler/f18@0506bb7a0c28cc9374c62eecfb7def724c5488fd
Reviewed-on: https://github.com/flang-compiler/f18/pull/183
Tree-same-pre-rewrite: false
---
 flang/lib/evaluate/expression.cc  | 1018 ++++++++++++++++---------------------
 flang/lib/evaluate/expression.h   |  428 ++++++++--------
 flang/lib/evaluate/type.h         |    3 -
 flang/lib/evaluate/variable.cc    |    2 +-
 flang/lib/semantics/expression.cc |    7 +-
 5 files changed, 634 insertions(+), 824 deletions(-)

diff --git a/flang/lib/evaluate/expression.cc b/flang/lib/evaluate/expression.cc
index 8fbaeec..13186a5 100644
--- a/flang/lib/evaluate/expression.cc
+++ b/flang/lib/evaluate/expression.cc
@@ -27,7 +27,7 @@ using namespace Fortran::parser::literals;
 
 namespace Fortran::evaluate {
 
-// Folding
+// Fold
 
 template<typename D, typename R, typename... O>
 auto Operation<D, R, O...>::Fold(FoldingContext &context)
@@ -46,6 +46,159 @@ auto Operation<D, R, O...>::Fold(FoldingContext &context)
   return std::nullopt;
 }
 
+template<int KIND>
+auto Expr<Type<TypeCategory::Integer, KIND>>::Fold(FoldingContext &context)
+    -> std::optional<Scalar<Result>> {
+  if (auto c{ScalarValue()}) {
+    return c;
+  }
+  return std::visit(
+      [&](auto &x) -> std::optional<Scalar<Result>> {
+        using Ty = std::decay_t<decltype(x)>;
+        if constexpr (evaluate::FoldableTrait<Ty>) {
+          if (auto c{x.Fold(context)}) {
+            if constexpr (std::is_same_v<Ty, Parentheses<Result>>) {
+              // Preserve parentheses around constants.
+              u_ = Parentheses<Result>{Expr{*c}};
+            } else {
+              u_ = *c;
+            }
+            return c;
+          }
+        }
+        return std::nullopt;
+      },
+      u_);
+}
+
+template<int KIND>
+auto Expr<Type<TypeCategory::Real, KIND>>::Fold(FoldingContext &context)
+    -> std::optional<Scalar<Result>> {
+  if (auto c{ScalarValue()}) {
+    return c;
+  }
+  return std::visit(
+      [&](auto &x) -> std::optional<Scalar<Result>> {
+        using Ty = std::decay_t<decltype(x)>;
+        if constexpr (evaluate::FoldableTrait<Ty>) {
+          if (auto c{x.Fold(context)}) {
+            if (context.flushDenormalsToZero) {
+              *c = c->FlushDenormalToZero();
+            }
+            if constexpr (std::is_same_v<Ty, Parentheses<Result>>) {
+              // Preserve parentheses around constants.
+              u_ = Parentheses<Result>{Expr{*c}};
+            } else {
+              u_ = *c;
+            }
+            return c;
+          }
+        }
+        return std::nullopt;
+      },
+      u_);
+}
+
+template<int KIND>
+auto Expr<Type<TypeCategory::Complex, KIND>>::Fold(FoldingContext &context)
+    -> std::optional<Scalar<Result>> {
+  if (auto c{ScalarValue()}) {
+    return c;
+  }
+  return std::visit(
+      [&](auto &x) -> std::optional<Scalar<Result>> {
+        using Ty = std::decay_t<decltype(x)>;
+        if constexpr (evaluate::FoldableTrait<Ty>) {
+          if (auto c{x.Fold(context)}) {
+            if (context.flushDenormalsToZero) {
+              *c = c->FlushDenormalToZero();
+            }
+            if constexpr (std::is_same_v<Ty, Parentheses<Result>>) {
+              // Preserve parentheses around constants.
+              u_ = Parentheses<Result>{Expr{*c}};
+            } else {
+              u_ = *c;
+            }
+            return c;
+          }
+        }
+        return std::nullopt;
+      },
+      u_);
+}
+
+template<int KIND>
+auto Expr<Type<TypeCategory::Character, KIND>>::Fold(FoldingContext &context)
+    -> std::optional<Scalar<Result>> {
+  if (auto c{ScalarValue()}) {
+    return c;
+  }
+  return std::visit(
+      [&](auto &x) -> std::optional<Scalar<Result>> {
+        using Ty = std::decay_t<decltype(x)>;
+        if constexpr (evaluate::FoldableTrait<Ty>) {
+          if (auto c{x.Fold(context)}) {
+            u_ = *c;
+            return c;
+          }
+        }
+        return std::nullopt;
+      },
+      u_);
+}
+
+template<int KIND>
+auto Expr<Type<TypeCategory::Logical, KIND>>::Fold(FoldingContext &context)
+    -> std::optional<Scalar<Result>> {
+  if (auto c{ScalarValue()}) {
+    return c;
+  }
+  return std::visit(
+      [&](auto &x) -> std::optional<Scalar<Result>> {
+        using Ty = std::decay_t<decltype(x)>;
+        if constexpr (evaluate::FoldableTrait<Ty>) {
+          if (auto c{x.Fold(context)}) {
+            Scalar<Result> result{c->IsTrue()};
+            u_ = result;
+            return {result};
+          }
+        }
+        return std::nullopt;
+      },
+      u_);
+}
+
+template<TypeCategory CAT>
+auto Expr<SomeKind<CAT>>::Fold(FoldingContext &context)
+    -> std::optional<Scalar<Result>> {
+  return std::visit(
+      [&](auto &x) -> std::optional<Scalar<Result>> {
+        if (auto c{x.Fold(context)}) {
+          return {Scalar<Result>{std::move(*c)}};
+        }
+        return std::nullopt;
+      },
+      u);
+}
+
+auto Expr<SomeType>::Fold(FoldingContext &context)
+    -> std::optional<Scalar<Result>> {
+  return std::visit(
+      common::visitors{
+          [](BOZLiteralConstant &) -> std::optional<Scalar<Result>> {
+            return std::nullopt;
+          },
+          [&](auto &x) -> std::optional<Scalar<Result>> {
+            if (auto c{x.Fold(context)}) {
+              return {Scalar<Result>{std::move(*c)}};
+            }
+            return std::nullopt;
+          }},
+      u);
+}
+
+// FoldScalar
+
 template<typename TO, typename FROM>
 auto Convert<TO, FROM>::FoldScalar(FoldingContext &context,
     const Scalar<Operand> &c) -> std::optional<Scalar<Result>> {
@@ -143,545 +296,148 @@ auto Add<A>::FoldScalar(FoldingContext &context, const Scalar<Operand> &x,
   if constexpr (Result::category == TypeCategory::Integer) {
     auto sum{x.AddSigned(y)};
     if (sum.overflow) {
-      context.messages.Say("INTEGER addition overflowed"_en_US);
-    } else {
-      return {std::move(sum.value)};
+      context.messages.Say(
+          "INTEGER(KIND=%d) addition overflowed"_en_US, Result::kind);
+      return std::nullopt;
     }
+    return {std::move(sum.value)};
   } else {
     auto sum{x.Add(y, context.rounding)};
     RealFlagWarnings(context, sum.flags, "addition");
     return {std::move(sum.value)};
   }
-  return std::nullopt;
-}
-
-// Dumping
-
-template<typename D, typename R, typename... O>
-std::ostream &Operation<D, R, O...>::Dump(std::ostream &o) const {
-  operand<0>().Dump(o << derived().prefix());
-  if constexpr (operands() > 1) {
-    operand<1>().Dump(o << derived().infix());
-  }
-  return o << derived().suffix();
 }
 
-template<typename A> std::string Comparison<A>::infix() const {
-  return "."s + EnumToString(opr) + '.';
-}
-
-template<typename... A>
-std::ostream &DumpExpr(std::ostream &o, const std::variant<A...> &u) {
-  std::visit(common::visitors{[&](const BOZLiteralConstant &x) {
-                                o << "Z'" << x.Hexadecimal() << "'";
-                              },
-                 [&](const auto &x) { x.Dump(o); }},
-      u);
-  return o;
-}
-
-template<TypeCategory CAT>
-std::ostream &Expr<SomeKind<CAT>>::Dump(std::ostream &o) const {
-  return DumpExpr(o, u);
-}
-
-template<TypeCategory CAT>
-std::ostream &CategoryComparison<CAT>::Dump(std::ostream &o) const {
-  return DumpExpr(o, u);
-}
-
-std::ostream &Expr<SomeType>::Dump(std::ostream &o) const {
-  return DumpExpr(o, u);
-}
-
-template<typename CRTP, typename RESULT, typename A, typename B>
-std::ostream &Binary<CRTP, RESULT, A, B>::Dump(
-    std::ostream &o, const char *opr, const char *before) const {
-  return right().Dump(left().Dump(o << before) << opr) << ')';
-}
-
-template<int KIND>
-std::ostream &Expr<Type<TypeCategory::Integer, KIND>>::Dump(
-    std::ostream &o) const {
-  std::visit(common::visitors{[&](const Scalar<Result> &n) {
-                                o << n.SignedDecimal() << '_' << KIND;
-                              },
-                 [&](const CopyableIndirection<DataRef> &d) { d->Dump(o); },
-                 [&](const CopyableIndirection<FunctionRef> &d) { d->Dump(o); },
-                 [&](const Subtract &s) { s.Dump(o, "-"); },
-                 [&](const Multiply &m) { m.Dump(o, "*"); },
-                 [&](const Divide &d) { d.Dump(o, "/"); },
-                 [&](const Power &p) { p.Dump(o, "**"); },
-                 [&](const Max &m) { m.Dump(o, ",", "MAX("); },
-                 [&](const Min &m) { m.Dump(o, ",", "MIN("); },
-                 [&](const auto &x) { x.Dump(o); }},
-      u_);
-  return o;
-}
-
-template<int KIND>
-std::ostream &Expr<Type<TypeCategory::Real, KIND>>::Dump(
-    std::ostream &o) const {
-  std::visit(common::visitors{[&](const Scalar<Result> &n) {
-                                o << n.DumpHexadecimal();
-                              },
-                 [&](const CopyableIndirection<DataRef> &d) { d->Dump(o); },
-                 [&](const CopyableIndirection<ComplexPart> &d) { d->Dump(o); },
-                 [&](const CopyableIndirection<FunctionRef> &d) { d->Dump(o); },
-                 [&](const Subtract &s) { s.Dump(o, "-"); },
-                 [&](const Multiply &m) { m.Dump(o, "*"); },
-                 [&](const Divide &d) { d.Dump(o, "/"); },
-                 [&](const Power &p) { p.Dump(o, "**"); },
-                 [&](const IntPower &p) { p.Dump(o, "**"); },
-                 [&](const Max &m) { m.Dump(o, ",", "MAX("); },
-                 [&](const Min &m) { m.Dump(o, ",", "MIN("); },
-                 [&](const auto &x) { x.Dump(o); }},
-      u_);
-  return o;
-}
-
-template<int KIND>
-std::ostream &Expr<Type<TypeCategory::Complex, KIND>>::Dump(
-    std::ostream &o) const {
-  std::visit(common::visitors{[&](const Scalar<Result> &n) {
-                                o << n.DumpHexadecimal();
-                              },
-                 [&](const CopyableIndirection<DataRef> &d) { d->Dump(o); },
-                 [&](const CopyableIndirection<FunctionRef> &d) { d->Dump(o); },
-                 [&](const Subtract &s) { s.Dump(o, "-"); },
-                 [&](const Multiply &m) { m.Dump(o, "*"); },
-                 [&](const Divide &d) { d.Dump(o, "/"); },
-                 [&](const Power &p) { p.Dump(o, "**"); },
-                 [&](const IntPower &p) { p.Dump(o, "**"); },
-                 [&](const CMPLX &c) { c.Dump(o, ","); },
-                 [&](const auto &x) { x.Dump(o); }},
-      u_);
-  return o;
-}
-
-template<int KIND>
-std::ostream &Expr<Type<TypeCategory::Character, KIND>>::Dump(
-    std::ostream &o) const {
-  std::visit(common::visitors{[&](const Scalar<Result> &s) {
-                                o << KIND << '_'
-                                  << parser::QuoteCharacterLiteral(s);
-                              },
-                 //          [&](const Parentheses<Result> &p) { p.Dump(o); },
-                 [&](const Concat &concat) { concat.Dump(o, "//"); },
-                 [&](const Max &m) { m.Dump(o, ",", "MAX("); },
-                 [&](const Min &m) { m.Dump(o, ",", "MIN("); },
-                 [&](const auto &ind) { ind->Dump(o); }},
-      u_);
-  return o;
-}
-
-template<int KIND>
-std::ostream &Expr<Type<TypeCategory::Logical, KIND>>::Dump(
-    std::ostream &o) const {
-  std::visit(common::visitors{[&](const Scalar<Result> &tf) {
-                                o << (tf.IsTrue() ? ".TRUE." : ".FALSE.") << '_'
-                                  << KIND;
-                              },
-                 [&](const CopyableIndirection<DataRef> &d) { d->Dump(o); },
-                 [&](const CopyableIndirection<FunctionRef> &d) { d->Dump(o); },
-                 //          [&](const Parentheses<Result> &p) { p.Dump(o); },
-                 [&](const Not<KIND> &n) { n.Dump(o); },
-                 [&](const And &a) { a.Dump(o, ".AND."); },
-                 [&](const Or &a) { a.Dump(o, ".OR."); },
-                 [&](const Eqv &a) { a.Dump(o, ".EQV."); },
-                 [&](const Neqv &a) { a.Dump(o, ".NEQV."); },
-                 [&](const auto &comparison) { comparison.Dump(o); }},
-      u_);
-  return o;
-}
-
-// LEN()
-template<int KIND>
-Expr<SubscriptInteger> Expr<Type<TypeCategory::Character, KIND>>::LEN() const {
-  return std::visit(
-      common::visitors{[](const Scalar<Result> &c) {
-                         // std::string::size_type isn't convertible to uint64_t
-                         // on Darwin
-                         return Expr<SubscriptInteger>{
-                             static_cast<std::uint64_t>(c.size())};
-                       },
-          [](const Concat &c) { return c.left().LEN() + c.right().LEN(); },
-          [](const Max &c) {
-            return Expr<SubscriptInteger>{
-                Expr<SubscriptInteger>::Max{c.left().LEN(), c.right().LEN()}};
-          },
-          [](const Min &c) {
-            return Expr<SubscriptInteger>{
-                Expr<SubscriptInteger>::Max{c.left().LEN(), c.right().LEN()}};
-          },
-          [](const CopyableIndirection<DataRef> &dr) { return dr->LEN(); },
-          [](const CopyableIndirection<Substring> &ss) { return ss->LEN(); },
-          [](const CopyableIndirection<FunctionRef> &fr) {
-            return fr->proc().LEN();
-          }},
-      u_);
-}
-
-// Rank
-template<typename CRTP, typename RESULT, typename A, typename B>
-int Binary<CRTP, RESULT, A, B>::Rank() const {
-  int lrank{left_.Rank()};
-  if (lrank > 0) {
-    return lrank;
-  }
-  return right_.Rank();
-}
-
-// Folding
-template<typename CRTP, typename RESULT, typename A, typename B>
-auto Binary<CRTP, RESULT, A, B>::Fold(FoldingContext &context)
-    -> std::optional<Scalar<Result>> {
-  std::optional<Scalar<Left>> lc{left_->Fold(context)};
-  std::optional<Scalar<Right>> rc{right_->Fold(context)};
-  if (lc.has_value() && rc.has_value()) {
-    return static_cast<CRTP *>(this)->FoldScalar(context, *lc, *rc);
-  }
-  return std::nullopt;
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Integer, KIND>>::Subtract::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  auto diff{a.SubtractSigned(b)};
-  if (diff.overflow) {
-    context.messages.Say("integer subtraction overflowed"_en_US);
-    return std::nullopt;
-  }
-  return {std::move(diff.value)};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Integer, KIND>>::Multiply::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  auto product{a.MultiplySigned(b)};
-  if (product.SignedMultiplicationOverflowed()) {
-    context.messages.Say("integer multiplication overflowed"_en_US);
-    return std::nullopt;
-  }
-  return {std::move(product.lower)};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Integer, KIND>>::Divide::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  auto qr{a.DivideSigned(b)};
-  if (qr.divisionByZero) {
-    context.messages.Say("integer division by zero"_en_US);
-    return std::nullopt;
-  }
-  if (qr.overflow) {
-    context.messages.Say("integer division overflowed"_en_US);
-    return std::nullopt;
-  }
-  return {std::move(qr.quotient)};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Integer, KIND>>::Power::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  typename Scalar<Result>::PowerWithErrors power{a.Power(b)};
-  if (power.divisionByZero) {
-    context.messages.Say("zero to negative power"_en_US);
-    return std::nullopt;
-  }
-  if (power.overflow) {
-    context.messages.Say("integer power overflowed"_en_US);
-    return std::nullopt;
-  }
-  if (power.zeroToZero) {
-    context.messages.Say("integer 0**0"_en_US);
-    return std::nullopt;
-  }
-  return {std::move(power.power)};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Integer, KIND>>::Max::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  if (a.CompareSigned(b) == Ordering::Greater) {
-    return {a};
-  }
-  return {b};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Integer, KIND>>::Min::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  if (a.CompareSigned(b) == Ordering::Less) {
-    return {a};
-  }
-  return {b};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Integer, KIND>>::Fold(FoldingContext &context)
-    -> std::optional<Scalar<Result>> {
-  if (auto c{ScalarValue()}) {
-    return c;
-  }
-  return std::visit(
-      [&](auto &x) -> std::optional<Scalar<Result>> {
-        using Ty = std::decay_t<decltype(x)>;
-        if constexpr (evaluate::FoldableTrait<Ty>) {
-          if (auto c{x.Fold(context)}) {
-            if constexpr (std::is_same_v<Ty, Parentheses<Result>>) {
-              // Preserve parentheses around constants.
-              u_ = Parentheses<Result>{Expr{*c}};
-            } else {
-              u_ = *c;
-            }
-            return c;
-          }
-        }
-        return std::nullopt;
-      },
-      u_);
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Real, KIND>>::Subtract::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  auto difference{a.Subtract(b, context.rounding)};
-  RealFlagWarnings(context, difference.flags, "real subtraction");
-  return {std::move(difference.value)};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Real, KIND>>::Multiply::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  auto product{a.Multiply(b, context.rounding)};
-  RealFlagWarnings(context, product.flags, "real multiplication");
-  return {std::move(product.value)};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Real, KIND>>::Divide::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  auto quotient{a.Divide(b, context.rounding)};
-  RealFlagWarnings(context, quotient.flags, "real division");
-  return {std::move(quotient.value)};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Real, KIND>>::Power::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  return std::nullopt;  // TODO
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Real, KIND>>::IntPower::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a,
-    const SomeKindScalar<TypeCategory::Integer> &b)
-    -> std::optional<Scalar<Result>> {
-  return std::visit(
-      [&](const auto &pow) -> std::optional<Scalar<Result>> {
-        auto power{evaluate::IntPower(a, pow)};
-        RealFlagWarnings(context, power.flags, "raising to integer power");
-        return {std::move(power.value)};
-      },
-      b.u);
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Real, KIND>>::Max::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  if (b.IsNotANumber() || a.Compare(b) == Relation::Less) {
-    return {b};
-  }
-  return {a};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Real, KIND>>::Min::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  if (b.IsNotANumber() || a.Compare(b) == Relation::Greater) {
-    return {b};
-  }
-  return {a};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Real, KIND>>::Fold(FoldingContext &context)
-    -> std::optional<Scalar<Result>> {
-  if (auto c{ScalarValue()}) {
-    return c;
-  }
-  return std::visit(
-      [&](auto &x) -> std::optional<Scalar<Result>> {
-        using Ty = std::decay_t<decltype(x)>;
-        if constexpr (evaluate::FoldableTrait<Ty>) {
-          if (auto c{x.Fold(context)}) {
-            if (context.flushDenormalsToZero) {
-              *c = c->FlushDenormalToZero();
-            }
-            if constexpr (std::is_same_v<Ty, Parentheses<Result>>) {
-              // Preserve parentheses around constants.
-              u_ = Parentheses<Result>{Expr{*c}};
-            } else {
-              u_ = *c;
-            }
-            return c;
-          }
-        }
-        return std::nullopt;
-      },
-      u_);
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Complex, KIND>>::Subtract::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  auto difference{a.Subtract(b, context.rounding)};
-  RealFlagWarnings(context, difference.flags, "complex subtraction");
-  return {std::move(difference.value)};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Complex, KIND>>::Multiply::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  auto product{a.Multiply(b, context.rounding)};
-  RealFlagWarnings(context, product.flags, "complex multiplication");
-  return {std::move(product.value)};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Complex, KIND>>::Divide::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  auto quotient{a.Divide(b, context.rounding)};
-  RealFlagWarnings(context, quotient.flags, "complex  division");
-  return {std::move(quotient.value)};
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Complex, KIND>>::Power::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  return std::nullopt;  // TODO
-}
-
-template<int KIND>
-auto Expr<Type<TypeCategory::Complex, KIND>>::IntPower::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a,
-    const SomeKindScalar<TypeCategory::Integer> &b)
-    -> std::optional<Scalar<Result>> {
-  return std::visit(
-      [&](const auto &pow) -> std::optional<Scalar<Result>> {
-        auto power{evaluate::IntPower(a, pow)};
-        RealFlagWarnings(context, power.flags, "raising to integer power");
-        return {std::move(power.value)};
-      },
-      b.u);
+template<typename A>
+auto Subtract<A>::FoldScalar(FoldingContext &context, const Scalar<Operand> &x,
+    const Scalar<Operand> &y) -> std::optional<Scalar<Result>> {
+  if constexpr (Result::category == TypeCategory::Integer) {
+    auto diff{x.SubtractSigned(y)};
+    if (diff.overflow) {
+      context.messages.Say(
+          "INTEGER(KIND=%d) subtraction overflowed"_en_US, Result::kind);
+      return std::nullopt;
+    }
+    return {std::move(diff.value)};
+  } else {
+    auto difference{x.Subtract(y, context.rounding)};
+    RealFlagWarnings(context, difference.flags, "subtraction");
+    return {std::move(difference.value)};
+  }
 }
 
-template<int KIND>
-auto Expr<Type<TypeCategory::Complex, KIND>>::CMPLX::FoldScalar(
-    FoldingContext &context,
-    const Scalar<SameKind<TypeCategory::Real, Result>> &a,
-    const Scalar<SameKind<TypeCategory::Real, Result>> &b)
-    -> std::optional<Scalar<Result>> {
-  return {Scalar<Result>{a, b}};
+template<typename A>
+auto Multiply<A>::FoldScalar(FoldingContext &context, const Scalar<Operand> &x,
+    const Scalar<Operand> &y) -> std::optional<Scalar<Result>> {
+  if constexpr (Result::category == TypeCategory::Integer) {
+    auto product{x.MultiplySigned(y)};
+    if (product.SignedMultiplicationOverflowed()) {
+      context.messages.Say(
+          "INTEGER(KIND=%d) multiplication overflowed"_en_US, Result::kind);
+      return std::nullopt;
+    }
+    return {std::move(product.lower)};
+  } else {
+    auto product{x.Multiply(y, context.rounding)};
+    RealFlagWarnings(context, product.flags, "multiplication");
+    return {std::move(product.value)};
+  }
 }
 
-template<int KIND>
-auto Expr<Type<TypeCategory::Complex, KIND>>::Fold(FoldingContext &context)
-    -> std::optional<Scalar<Result>> {
-  if (auto c{ScalarValue()}) {
-    return c;
+template<typename A>
+auto Divide<A>::FoldScalar(FoldingContext &context, const Scalar<Operand> &x,
+    const Scalar<Operand> &y) -> std::optional<Scalar<Result>> {
+  if constexpr (Result::category == TypeCategory::Integer) {
+    auto qr{x.DivideSigned(y)};
+    if (qr.divisionByZero) {
+      context.messages.Say("INTEGER division by zero"_en_US);
+      return std::nullopt;
+    }
+    if (qr.overflow) {
+      context.messages.Say(
+          "INTEGER(KIND=%d) division overflowed"_en_US, Result::kind);
+      return std::nullopt;
+    }
+    return {std::move(qr.quotient)};
+  } else {
+    auto quotient{x.Divide(y, context.rounding)};
+    RealFlagWarnings(context, quotient.flags, "division");
+    return {std::move(quotient.value)};
   }
-  return std::visit(
-      [&](auto &x) -> std::optional<Scalar<Result>> {
-        using Ty = std::decay_t<decltype(x)>;
-        if constexpr (evaluate::FoldableTrait<Ty>) {
-          if (auto c{x.Fold(context)}) {
-            if (context.flushDenormalsToZero) {
-              *c = c->FlushDenormalToZero();
-            }
-            if constexpr (std::is_same_v<Ty, Parentheses<Result>>) {
-              // Preserve parentheses around constants.
-              u_ = Parentheses<Result>{Expr{*c}};
-            } else {
-              u_ = *c;
-            }
-            return c;
-          }
-        }
-        return std::nullopt;
-      },
-      u_);
 }
 
-template<int KIND>
-auto Expr<Type<TypeCategory::Character, KIND>>::Concat::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  if constexpr (KIND == 1) {
-    return {a + b};
+template<typename A>
+auto Power<A>::FoldScalar(FoldingContext &context, const Scalar<Operand> &x,
+    const Scalar<Operand> &y) -> std::optional<Scalar<Result>> {
+  if constexpr (Result::category == TypeCategory::Integer) {
+    typename Scalar<Result>::PowerWithErrors power{x.Power(y)};
+    if (power.divisionByZero) {
+      context.messages.Say("zero to negative power"_en_US);
+    } else if (power.overflow) {
+      context.messages.Say(
+          "INTEGER(KIND=%d) power overflowed"_en_US, Result::kind);
+    } else if (power.zeroToZero) {
+      context.messages.Say("INTEGER 0**0 is not defined"_en_US);
+    } else {
+      return {std::move(power.power)};
+    }
+  } else {
+    // TODO: real and complex exponentiation to non-integer powers
   }
   return std::nullopt;
 }
 
-template<int KIND>
-auto Expr<Type<TypeCategory::Character, KIND>>::Max::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
+template<typename A, typename B>
+auto RealToIntPower<A, B>::FoldScalar(FoldingContext &context,
+    const Scalar<Operand> &x, const Scalar<ExponentOperand> &y)
     -> std::optional<Scalar<Result>> {
-  if (Compare(a, b) == Ordering::Less) {
-    return {b};
+  return std::visit(
+      [&](const auto &pow) -> std::optional<Scalar<Result>> {
+        auto power{evaluate::IntPower(x, pow)};
+        RealFlagWarnings(context, power.flags, "raising to INTEGER power");
+        return {std::move(power.value)};
+      },
+      y.u);
+}
+
+template<typename A>
+auto Extremum<A>::FoldScalar(FoldingContext &context, const Scalar<Operand> &x,
+    const Scalar<Operand> &y) const -> std::optional<Scalar<Result>> {
+  if constexpr (Operand::category == TypeCategory::Integer) {
+    if (ordering == x.CompareSigned(y)) {
+      return {x};
+    }
+  } else if constexpr (Operand::category == TypeCategory::Real) {
+    if (x.IsNotANumber() ||
+        (x.Compare(y) == Relation::Less) == (ordering == Ordering::Less)) {
+      return {x};
+    }
+  } else {
+    if (ordering == Compare(x, y)) {
+      return {x};
+    }
   }
-  return {a};
+  return {y};
 }
 
 template<int KIND>
-auto Expr<Type<TypeCategory::Character, KIND>>::Min::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
+auto ComplexConstructor<KIND>::FoldScalar(
+    FoldingContext &context, const Scalar<Operand> &x, const Scalar<Operand> &y)
     -> std::optional<Scalar<Result>> {
-  if (Compare(a, b) == Ordering::Greater) {
-    return {b};
-  }
-  return {a};
+  return {Scalar<Result>{x, y}};
 }
 
 template<int KIND>
-auto Expr<Type<TypeCategory::Character, KIND>>::Fold(FoldingContext &context)
-    -> std::optional<Scalar<Result>> {
-  if (auto c{ScalarValue()}) {
-    return c;
+auto Concat<KIND>::FoldScalar(FoldingContext &context, const Scalar<Operand> &x,
+    const Scalar<Operand> &y) -> std::optional<Scalar<Result>> {
+  if constexpr (KIND == 1) {
+    return {x + y};
   }
-  return std::visit(
-      [&](auto &x) -> std::optional<Scalar<Result>> {
-        using Ty = std::decay_t<decltype(x)>;
-        if constexpr (evaluate::FoldableTrait<Ty>) {
-          if (auto c{x.Fold(context)}) {
-            u_ = *c;
-            return c;
-          }
-        }
-        return std::nullopt;
-      },
-      u_);
+  return std::nullopt;
 }
 
 template<typename A>
-auto Comparison<A>::FoldScalar(FoldingContext &c, const Scalar<Operand> &a,
+auto Relational<A>::FoldScalar(FoldingContext &c, const Scalar<Operand> &a,
     const Scalar<Operand> &b) -> std::optional<Scalar<Result>> {
   if constexpr (A::category == TypeCategory::Integer) {
     switch (a.CompareSigned(b)) {
@@ -732,68 +488,166 @@ auto Comparison<A>::FoldScalar(FoldingContext &c, const Scalar<Operand> &a,
 }
 
 template<int KIND>
-auto Expr<Type<TypeCategory::Logical, KIND>>::And::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
+auto LogicalOperation<KIND>::FoldScalar(FoldingContext &context,
+    const Scalar<Operand> &x, const Scalar<Operand> &y) const
     -> std::optional<Scalar<Result>> {
-  return {Scalar<Result>{a.IsTrue() && b.IsTrue()}};
+  bool xt{x.IsTrue()}, yt{y.IsTrue()};
+  switch (logicalOperator) {
+  case LogicalOperator::And: return {Scalar<Result>{xt && yt}};
+  case LogicalOperator::Or: return {Scalar<Result>{xt || yt}};
+  case LogicalOperator::Eqv: return {Scalar<Result>{xt == yt}};
+  case LogicalOperator::Neqv: return {Scalar<Result>{xt != yt}};
+  }
+  return std::nullopt;
+}
+
+// Dump
+
+template<typename D, typename R, typename... O>
+std::ostream &Operation<D, R, O...>::Dump(std::ostream &o) const {
+  operand<0>().Dump(o << derived().prefix());
+  if constexpr (operands() > 1) {
+    operand<1>().Dump(o << derived().infix());
+  }
+  return o << derived().suffix();
+}
+
+template<typename A> std::string Relational<A>::infix() const {
+  return "."s + EnumToString(opr) + '.';
+}
+
+template<int KIND> const char *LogicalOperation<KIND>::infix() const {
+  const char *result{nullptr};
+  switch (logicalOperator) {
+  case LogicalOperator::And: result = ".AND."; break;
+  case LogicalOperator::Or: result = ".OR."; break;
+  case LogicalOperator::Eqv: result = ".EQV."; break;
+  case LogicalOperator::Neqv: result = ".NEQV."; break;
+  }
+  return result;
+}
+
+template<typename... A>
+std::ostream &DumpExpr(std::ostream &o, const std::variant<A...> &u) {
+  std::visit(common::visitors{[&](const BOZLiteralConstant &x) {
+                                o << "Z'" << x.Hexadecimal() << "'";
+                              },
+                 [&](const auto &x) { x.Dump(o); }},
+      u);
+  return o;
+}
+
+template<TypeCategory CAT>
+std::ostream &Expr<SomeKind<CAT>>::Dump(std::ostream &o) const {
+  return DumpExpr(o, u);
+}
+
+template<TypeCategory CAT>
+std::ostream &Relational<SomeKind<CAT>>::Dump(std::ostream &o) const {
+  return DumpExpr(o, u);
+}
+
+std::ostream &Expr<SomeType>::Dump(std::ostream &o) const {
+  return DumpExpr(o, u);
 }
 
 template<int KIND>
-auto Expr<Type<TypeCategory::Logical, KIND>>::Or::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  return {Scalar<Result>{a.IsTrue() || b.IsTrue()}};
+std::ostream &Expr<Type<TypeCategory::Integer, KIND>>::Dump(
+    std::ostream &o) const {
+  std::visit(common::visitors{[&](const Scalar<Result> &n) {
+                                o << n.SignedDecimal() << '_' << KIND;
+                              },
+                 [&](const CopyableIndirection<DataRef> &d) { d->Dump(o); },
+                 [&](const CopyableIndirection<FunctionRef> &d) { d->Dump(o); },
+                 [&](const auto &x) { x.Dump(o); }},
+      u_);
+  return o;
 }
 
 template<int KIND>
-auto Expr<Type<TypeCategory::Logical, KIND>>::Eqv::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  return {Scalar<Result>{a.IsTrue() == b.IsTrue()}};
+std::ostream &Expr<Type<TypeCategory::Real, KIND>>::Dump(
+    std::ostream &o) const {
+  std::visit(common::visitors{[&](const Scalar<Result> &n) {
+                                o << n.DumpHexadecimal();
+                              },
+                 [&](const CopyableIndirection<DataRef> &d) { d->Dump(o); },
+                 [&](const CopyableIndirection<ComplexPart> &d) { d->Dump(o); },
+                 [&](const CopyableIndirection<FunctionRef> &d) { d->Dump(o); },
+                 [&](const auto &x) { x.Dump(o); }},
+      u_);
+  return o;
 }
 
 template<int KIND>
-auto Expr<Type<TypeCategory::Logical, KIND>>::Neqv::FoldScalar(
-    FoldingContext &context, const Scalar<Result> &a, const Scalar<Result> &b)
-    -> std::optional<Scalar<Result>> {
-  return {Scalar<Result>{a.IsTrue() != b.IsTrue()}};
+std::ostream &Expr<Type<TypeCategory::Complex, KIND>>::Dump(
+    std::ostream &o) const {
+  std::visit(common::visitors{[&](const Scalar<Result> &n) {
+                                o << n.DumpHexadecimal();
+                              },
+                 [&](const CopyableIndirection<DataRef> &d) { d->Dump(o); },
+                 [&](const CopyableIndirection<FunctionRef> &d) { d->Dump(o); },
+                 [&](const auto &x) { x.Dump(o); }},
+      u_);
+  return o;
 }
 
 template<int KIND>
-auto Expr<Type<TypeCategory::Logical, KIND>>::Fold(FoldingContext &context)
-    -> std::optional<Scalar<Result>> {
-  if (auto c{ScalarValue()}) {
-    return c;
-  }
-  return std::visit(
-      [&](auto &x) -> std::optional<Scalar<Result>> {
-        using Ty = std::decay_t<decltype(x)>;
-        if constexpr (evaluate::FoldableTrait<Ty>) {
-          if (auto c{x.Fold(context)}) {
-            u_ = *c;
-            return c;
-          }
-        }
-        return std::nullopt;
-      },
+std::ostream &Expr<Type<TypeCategory::Character, KIND>>::Dump(
+    std::ostream &o) const {
+  std::visit(common::visitors{[&](const Scalar<Result> &s) {
+                                o << KIND << '_'
+                                  << parser::QuoteCharacterLiteral(s);
+                              },
+                 //          [&](const Parentheses<Result> &p) { p.Dump(o); },
+                 [&](const Concat<KIND> &c) { c.Dump(o); },
+                 [&](const Extremum<Result> &mm) { mm.Dump(o); },
+                 [&](const auto &ind) { ind->Dump(o); }},
       u_);
+  return o;
 }
 
-auto Expr<SomeType>::ScalarValue() const -> std::optional<Scalar<Result>> {
+template<int KIND>
+std::ostream &Expr<Type<TypeCategory::Logical, KIND>>::Dump(
+    std::ostream &o) const {
+  std::visit(common::visitors{[&](const Scalar<Result> &tf) {
+                                o << (tf.IsTrue() ? ".TRUE." : ".FALSE.") << '_'
+                                  << KIND;
+                              },
+                 [&](const CopyableIndirection<DataRef> &d) { d->Dump(o); },
+                 [&](const CopyableIndirection<FunctionRef> &d) { d->Dump(o); },
+                 [&](const auto &x) { x.Dump(o); }},
+      u_);
+  return o;
+}
+
+// LEN()
+template<int KIND>
+Expr<SubscriptInteger> Expr<Type<TypeCategory::Character, KIND>>::LEN() const {
   return std::visit(
-      common::visitors{
-          [](const BOZLiteralConstant &) -> std::optional<Scalar<Result>> {
-            return std::nullopt;
+      common::visitors{[](const Scalar<Result> &c) {
+                         // std::string::size_type isn't convertible to uint64_t
+                         // on Darwin
+                         return Expr<SubscriptInteger>{
+                             static_cast<std::uint64_t>(c.size())};
+                       },
+          [](const Concat<KIND> &c) {
+            return c.template operand<0>().LEN() +
+                c.template operand<1>().LEN();
           },
-          [](const auto &x) -> std::optional<Scalar<Result>> {
-            if (auto c{x.ScalarValue()}) {
-              return {Scalar<Result>{std::move(*c)}};
-            }
-            return std::nullopt;
+          [](const Extremum<Result> &c) {
+            return Expr<SubscriptInteger>{Extremum<SubscriptInteger>{
+                c.template operand<0>().LEN(), c.template operand<1>().LEN()}};
+          },
+          [](const CopyableIndirection<DataRef> &dr) { return dr->LEN(); },
+          [](const CopyableIndirection<Substring> &ss) { return ss->LEN(); },
+          [](const CopyableIndirection<FunctionRef> &fr) {
+            return fr->proc().LEN();
           }},
-      u);
+      u_);
 }
 
+// ScalarValue
+
 template<TypeCategory CAT>
 auto Expr<SomeKind<CAT>>::ScalarValue() const -> std::optional<Scalar<Result>> {
   return std::visit(
@@ -806,32 +660,14 @@ auto Expr<SomeKind<CAT>>::ScalarValue() const -> std::optional<Scalar<Result>> {
       u);
 }
 
-template<TypeCategory CAT>
-auto Expr<SomeKind<CAT>>::Fold(FoldingContext &context)
-    -> std::optional<Scalar<Result>> {
-  return std::visit(
-      [&](auto &x) -> std::optional<Scalar<Result>> {
-        if (auto c{x.Fold(context)}) {
-          return {Scalar<Result>{std::move(*c)}};
-        }
-        return std::nullopt;
-      },
-      u);
-}
-
-template<TypeCategory CAT> int Expr<SomeKind<CAT>>::Rank() const {
-  return std::visit([](const auto &x) { return x.Rank(); }, u);
-}
-
-auto Expr<SomeType>::Fold(FoldingContext &context)
-    -> std::optional<Scalar<Result>> {
+auto Expr<SomeType>::ScalarValue() const -> std::optional<Scalar<Result>> {
   return std::visit(
       common::visitors{
-          [](BOZLiteralConstant &) -> std::optional<Scalar<Result>> {
+          [](const BOZLiteralConstant &) -> std::optional<Scalar<Result>> {
             return std::nullopt;
           },
-          [&](auto &x) -> std::optional<Scalar<Result>> {
-            if (auto c{x.Fold(context)}) {
+          [](const auto &x) -> std::optional<Scalar<Result>> {
+            if (auto c{x.ScalarValue()}) {
               return {Scalar<Result>{std::move(*c)}};
             }
             return std::nullopt;
@@ -839,6 +675,12 @@ auto Expr<SomeType>::Fold(FoldingContext &context)
       u);
 }
 
+// Rank
+
+template<TypeCategory CAT> int Expr<SomeKind<CAT>>::Rank() const {
+  return std::visit([](const auto &x) { return x.Rank(); }, u);
+}
+
 int Expr<SomeType>::Rank() const {
   // Written thus, instead of common::visitors, to dodge a bug in G++ 7.2.
   return std::visit(
@@ -853,6 +695,8 @@ int Expr<SomeType>::Rank() const {
       u);
 }
 
+// Template instantiations
+
 template class Expr<Type<TypeCategory::Integer, 1>>;
 template class Expr<Type<TypeCategory::Integer, 2>>;
 template class Expr<Type<TypeCategory::Integer, 4>>;
@@ -870,22 +714,22 @@ template class Expr<Type<TypeCategory::Complex, 10>>;
 template class Expr<Type<TypeCategory::Complex, 16>>;
 template class Expr<Type<TypeCategory::Character, 1>>;  // TODO others
 
-template struct Comparison<Type<TypeCategory::Integer, 1>>;
-template struct Comparison<Type<TypeCategory::Integer, 2>>;
-template struct Comparison<Type<TypeCategory::Integer, 4>>;
-template struct Comparison<Type<TypeCategory::Integer, 8>>;
-template struct Comparison<Type<TypeCategory::Integer, 16>>;
-template struct Comparison<Type<TypeCategory::Real, 2>>;
-template struct Comparison<Type<TypeCategory::Real, 4>>;
-template struct Comparison<Type<TypeCategory::Real, 8>>;
-template struct Comparison<Type<TypeCategory::Real, 10>>;
-template struct Comparison<Type<TypeCategory::Real, 16>>;
-template struct Comparison<Type<TypeCategory::Complex, 2>>;
-template struct Comparison<Type<TypeCategory::Complex, 4>>;
-template struct Comparison<Type<TypeCategory::Complex, 8>>;
-template struct Comparison<Type<TypeCategory::Complex, 10>>;
-template struct Comparison<Type<TypeCategory::Complex, 16>>;
-template struct Comparison<Type<TypeCategory::Character, 1>>;  // TODO others
+template struct Relational<Type<TypeCategory::Integer, 1>>;
+template struct Relational<Type<TypeCategory::Integer, 2>>;
+template struct Relational<Type<TypeCategory::Integer, 4>>;
+template struct Relational<Type<TypeCategory::Integer, 8>>;
+template struct Relational<Type<TypeCategory::Integer, 16>>;
+template struct Relational<Type<TypeCategory::Real, 2>>;
+template struct Relational<Type<TypeCategory::Real, 4>>;
+template struct Relational<Type<TypeCategory::Real, 8>>;
+template struct Relational<Type<TypeCategory::Real, 10>>;
+template struct Relational<Type<TypeCategory::Real, 16>>;
+template struct Relational<Type<TypeCategory::Complex, 2>>;
+template struct Relational<Type<TypeCategory::Complex, 4>>;
+template struct Relational<Type<TypeCategory::Complex, 8>>;
+template struct Relational<Type<TypeCategory::Complex, 10>>;
+template struct Relational<Type<TypeCategory::Complex, 16>>;
+template struct Relational<Type<TypeCategory::Character, 1>>;  // TODO others
 
 template class Expr<Type<TypeCategory::Logical, 1>>;
 template class Expr<Type<TypeCategory::Logical, 2>>;
diff --git a/flang/lib/evaluate/expression.h b/flang/lib/evaluate/expression.h
index d805b3f..9d692a4 100644
--- a/flang/lib/evaluate/expression.h
+++ b/flang/lib/evaluate/expression.h
@@ -36,6 +36,10 @@ namespace Fortran::evaluate {
 
 using common::RelationalOperator;
 
+// Expr<A> represents an expression whose result is the Fortran type A,
+// which can be specific, SomeKind<C> for a type category C, or
+// Expr<SomeType> for a wholly generic expression.  Instances of Expr<>
+// wrap discriminated unions.
 template<typename A> class Expr;
 
 template<typename DERIVED, typename RESULT, typename... OPERAND>
@@ -127,7 +131,6 @@ struct ComplexComponent
 
   std::optional<Scalar<Result>> FoldScalar(
       FoldingContext &, const Scalar<Operand> &) const;
-  static const char *prefix() { return "(("; }
   const char *suffix() const { return isRealPart ? "%RE)" : "%IM)"; }
 
   bool isRealPart{true};
@@ -138,9 +141,9 @@ struct Not : public Operation<Not<KIND>, Type<TypeCategory::Logical, KIND>,
                  Type<TypeCategory::Logical, KIND>> {
   using Base = Operation<Not, Type<TypeCategory::Logical, KIND>,
       Type<TypeCategory::Logical, KIND>>;
-  using Base::Base;
   using typename Base::Result;
   using Operand = typename Base::template Operand<0>;
+  using Base::Base;
   static std::optional<Scalar<Result>> FoldScalar(
       FoldingContext &, const Scalar<Operand> &);
   static const char *prefix() { return "(.NOT."; }
@@ -150,40 +153,138 @@ struct Not : public Operation<Not<KIND>, Type<TypeCategory::Logical, KIND>,
 
 template<typename A> struct Add : public Operation<Add<A>, A, A, A> {
   using Base = Operation<Add, A, A, A>;
+  using typename Base::Result;
+  using Operand = typename Base::template Operand<0>;
   using Base::Base;
+  static std::optional<Scalar<Result>> FoldScalar(
+      FoldingContext &, const Scalar<Operand> &, const Scalar<Operand> &);
+  static constexpr const char *infix() { return "+"; }
+};
+
+template<typename A> struct Subtract : public Operation<Subtract<A>, A, A, A> {
+  using Base = Operation<Subtract, A, A, A>;
   using typename Base::Result;
   using Operand = typename Base::template Operand<0>;
+  using Base::Base;
   static std::optional<Scalar<Result>> FoldScalar(
       FoldingContext &, const Scalar<Operand> &, const Scalar<Operand> &);
-  static const char *infix() { return "+"; }
+  static constexpr const char *infix() { return "-"; }
 };
 
-template<typename CRTP, typename RESULT, typename A = RESULT, typename B = A>
-class Binary {
-public:
-  using Result = RESULT;
-  using Left = A;
-  using Right = B;
-  using FoldableTrait = std::true_type;
-  CLASS_BOILERPLATE(Binary)
-  Binary(const Expr<Left> &a, const Expr<Right> &b) : left_{a}, right_{b} {}
-  Binary(Expr<Left> &&a, Expr<Right> &&b)
-    : left_{std::move(a)}, right_{std::move(b)} {}
-  Binary(CopyableIndirection<const Expr<Left>> &&a,
-      CopyableIndirection<const Expr<Right>> &&b)
-    : left_{std::move(a)}, right_{std::move(b)} {}
-  const Expr<Left> &left() const { return *left_; }
-  Expr<Left> &left() { return *left_; }
-  const Expr<Right> &right() const { return *right_; }
-  Expr<Right> &right() { return *right_; }
-  std::ostream &Dump(
-      std::ostream &, const char *opr, const char *before = "(") const;
-  int Rank() const;
-  std::optional<Scalar<Result>> Fold(FoldingContext &);
+template<typename A> struct Multiply : public Operation<Multiply<A>, A, A, A> {
+  using Base = Operation<Multiply, A, A, A>;
+  using typename Base::Result;
+  using Operand = typename Base::template Operand<0>;
+  using Base::Base;
+  static std::optional<Scalar<Result>> FoldScalar(
+      FoldingContext &, const Scalar<Operand> &, const Scalar<Operand> &);
+  static constexpr const char *infix() { return "*"; }
+};
 
-private:
-  CopyableIndirection<Expr<Left>> left_;
-  CopyableIndirection<Expr<Right>> right_;
+template<typename A> struct Divide : public Operation<Divide<A>, A, A, A> {
+  using Base = Operation<Divide, A, A, A>;
+  using typename Base::Result;
+  using Operand = typename Base::template Operand<0>;
+  using Base::Base;
+  static std::optional<Scalar<Result>> FoldScalar(
+      FoldingContext &, const Scalar<Operand> &, const Scalar<Operand> &);
+  static constexpr const char *infix() { return "/"; }
+};
+
+template<typename A> struct Power : public Operation<Power<A>, A, A, A> {
+  using Base = Operation<Power, A, A, A>;
+  using typename Base::Result;
+  using Operand = typename Base::template Operand<0>;
+  using Base::Base;
+  static std::optional<Scalar<Result>> FoldScalar(
+      FoldingContext &, const Scalar<Operand> &, const Scalar<Operand> &);
+  static constexpr const char *infix() { return "**"; }
+};
+
+template<typename A, typename B>
+struct RealToIntPower : public Operation<RealToIntPower<A, B>, A, A, B> {
+  using Base = Operation<RealToIntPower, A, A, B>;
+  using typename Base::Result;
+  using Operand = typename Base::template Operand<0>;
+  using ExponentOperand = typename Base::template Operand<1>;
+  using Base::Base;
+  static std::optional<Scalar<Result>> FoldScalar(FoldingContext &,
+      const Scalar<Operand> &, const Scalar<ExponentOperand> &);
+  static constexpr const char *infix() { return "**"; }
+};
+
+template<typename A> struct Extremum : public Operation<Extremum<A>, A, A, A> {
+  using Base = Operation<Extremum, A, A, A>;
+  using typename Base::Result;
+  using Operand = typename Base::template Operand<0>;
+  CLASS_BOILERPLATE(Extremum)
+  Extremum(const Expr<Operand> &x, const Expr<Operand> &y,
+      Ordering ord = Ordering::Greater)
+    : Base{x, y}, ordering{ord} {}
+  Extremum(
+      Expr<Operand> &&x, Expr<Operand> &&y, Ordering ord = Ordering::Greater)
+    : Base{std::move(x), std::move(y)}, ordering{ord} {}
+
+  std::optional<Scalar<Result>> FoldScalar(
+      FoldingContext &, const Scalar<Operand> &, const Scalar<Operand> &) const;
+  const char *prefix() const {
+    return ordering == Ordering::Less ? "MIN(" : "MAX(";
+  }
+
+  Ordering ordering{Ordering::Greater};
+};
+
+template<int KIND>
+struct ComplexConstructor
+  : public Operation<ComplexConstructor<KIND>,
+        Type<TypeCategory::Complex, KIND>, Type<TypeCategory::Real, KIND>,
+        Type<TypeCategory::Real, KIND>> {
+  using Base = Operation<ComplexConstructor, Type<TypeCategory::Complex, KIND>,
+      Type<TypeCategory::Real, KIND>, Type<TypeCategory::Real, KIND>>;
+  using typename Base::Result;
+  using Operand = typename Base::template Operand<0>;
+  using Base::Base;
+  static std::optional<Scalar<Result>> FoldScalar(
+      FoldingContext &, const Scalar<Operand> &, const Scalar<Operand> &);
+};
+
+template<int KIND>
+struct Concat
+  : public Operation<Concat<KIND>, Type<TypeCategory::Character, KIND>,
+        Type<TypeCategory::Character, KIND>,
+        Type<TypeCategory::Character, KIND>> {
+  using Base = Operation<Concat, Type<TypeCategory::Character, KIND>,
+      Type<TypeCategory::Character, KIND>, Type<TypeCategory::Character, KIND>>;
+  using typename Base::Result;
+  using Operand = typename Base::template Operand<0>;
+  using Base::Base;
+  static std::optional<Scalar<Result>> FoldScalar(
+      FoldingContext &, const Scalar<Operand> &, const Scalar<Operand> &);
+  static constexpr const char *infix() { return "//"; }
+};
+
+ENUM_CLASS(LogicalOperator, And, Or, Eqv, Neqv)
+
+template<int KIND>
+struct LogicalOperation
+  : public Operation<LogicalOperation<KIND>, Type<TypeCategory::Logical, KIND>,
+        Type<TypeCategory::Logical, KIND>, Type<TypeCategory::Logical, KIND>> {
+  using Base = Operation<LogicalOperation, Type<TypeCategory::Logical, KIND>,
+      Type<TypeCategory::Logical, KIND>, Type<TypeCategory::Logical, KIND>>;
+  using typename Base::Result;
+  using Operand = typename Base::template Operand<0>;
+  CLASS_BOILERPLATE(LogicalOperation)
+  LogicalOperation(
+      const Expr<Operand> &x, const Expr<Operand> &y, LogicalOperator opr)
+    : Base{x, y}, logicalOperator{opr} {}
+  LogicalOperation(Expr<Operand> &&x, Expr<Operand> &&y, LogicalOperator opr)
+    : Base{std::move(x), std::move(y)}, logicalOperator{opr} {}
+
+  std::optional<Scalar<Result>> FoldScalar(
+      FoldingContext &, const Scalar<Operand> &, const Scalar<Operand> &) const;
+  const char *infix() const;
+
+  LogicalOperator logicalOperator;
 };
 
 // Per-category expressions
@@ -192,38 +293,6 @@ template<int KIND> class Expr<Type<TypeCategory::Integer, KIND>> {
 public:
   using Result = Type<TypeCategory::Integer, KIND>;
   using FoldableTrait = std::true_type;
-
-  template<typename CRTP> using Bin = Binary<CRTP, Result>;
-  struct Subtract : public Bin<Subtract> {
-    using Bin<Subtract>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Multiply : public Bin<Multiply> {
-    using Bin<Multiply>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Divide : public Bin<Divide> {
-    using Bin<Divide>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Power : public Bin<Power> {
-    using Bin<Power>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Max : public Bin<Max> {
-    using Bin<Max>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Min : public Bin<Min> {
-    using Bin<Min>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
   // TODO: R916 type-param-inquiry
 
   CLASS_BOILERPLATE(Expr)
@@ -265,7 +334,8 @@ private:
   std::variant<Scalar<Result>, CopyableIndirection<DataRef>,
       CopyableIndirection<FunctionRef>, Convert<Result, SomeInteger>,
       Convert<Result, SomeReal>, Parentheses<Result>, Negate<Result>,
-      Add<Result>, Subtract, Multiply, Divide, Power, Max, Min>
+      Add<Result>, Subtract<Result>, Multiply<Result>, Divide<Result>,
+      Power<Result>, Extremum<Result>>
       u_;
 };
 
@@ -278,43 +348,6 @@ public:
   // and part access operations (resp.).  Conversions between kinds of
   // Complex are done via decomposition to Real and reconstruction.
 
-  template<typename CRTP> using Bin = Binary<CRTP, Result>;
-  struct Subtract : public Bin<Subtract> {
-    using Bin<Subtract>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Multiply : public Bin<Multiply> {
-    using Bin<Multiply>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Divide : public Bin<Divide> {
-    using Bin<Divide>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Power : public Bin<Power> {
-    using Bin<Power>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct IntPower : public Binary<IntPower, Result, Result, SomeInteger> {
-    using Binary<IntPower, Result, Result, SomeInteger>::Binary;
-    static std::optional<Scalar<Result>> FoldScalar(FoldingContext &,
-        const Scalar<Result> &, const SomeKindScalar<TypeCategory::Integer> &);
-  };
-  struct Max : public Bin<Max> {
-    using Bin<Max>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Min : public Bin<Min> {
-    using Bin<Min>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-
   CLASS_BOILERPLATE(Expr)
   Expr(const Scalar<Result> &x) : u_{x} {}
   Expr(const Expr<SomeInteger> &x) : u_{Convert<Result, SomeInteger>{x}} {}
@@ -352,7 +385,8 @@ private:
       CopyableIndirection<ComplexPart>, CopyableIndirection<FunctionRef>,
       Convert<Result, SomeInteger>, Convert<Result, SomeReal>,
       ComplexComponent<KIND>, Parentheses<Result>, Negate<Result>, Add<Result>,
-      Subtract, Multiply, Divide, Power, IntPower, Max, Min>
+      Subtract<Result>, Multiply<Result>, Divide<Result>, Power<Result>,
+      RealToIntPower<Result, SomeInteger>, Extremum<Result>>
       u_;
 };
 
@@ -360,41 +394,6 @@ template<int KIND> class Expr<Type<TypeCategory::Complex, KIND>> {
 public:
   using Result = Type<TypeCategory::Complex, KIND>;
   using FoldableTrait = std::true_type;
-
-  template<typename CRTP> using Bin = Binary<CRTP, Result>;
-  struct Subtract : public Bin<Subtract> {
-    using Bin<Subtract>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Multiply : public Bin<Multiply> {
-    using Bin<Multiply>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Divide : public Bin<Divide> {
-    using Bin<Divide>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Power : public Bin<Power> {
-    using Bin<Power>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct IntPower : public Binary<IntPower, Result, Result, SomeInteger> {
-    using Binary<IntPower, Result, Result, SomeInteger>::Binary;
-    static std::optional<Scalar<Result>> FoldScalar(FoldingContext &,
-        const Scalar<Result> &, const SomeKindScalar<TypeCategory::Integer> &);
-  };
-  struct CMPLX
-    : public Binary<CMPLX, Result, SameKind<TypeCategory::Real, Result>> {
-    using Binary<CMPLX, Result, SameKind<TypeCategory::Real, Result>>::Binary;
-    static std::optional<Scalar<Result>> FoldScalar(FoldingContext &,
-        const Scalar<SameKind<TypeCategory::Real, Result>> &,
-        const Scalar<SameKind<TypeCategory::Real, Result>> &);
-  };
-
   CLASS_BOILERPLATE(Expr)
   Expr(const Scalar<Result> &x) : u_{x} {}
   template<typename A> Expr(const A &x) : u_{x} {}
@@ -413,7 +412,9 @@ public:
 private:
   std::variant<Scalar<Result>, CopyableIndirection<DataRef>,
       CopyableIndirection<FunctionRef>, Parentheses<Result>, Negate<Result>,
-      Add<Result>, Subtract, Multiply, Divide, Power, IntPower, CMPLX>
+      Add<Result>, Subtract<Result>, Multiply<Result>, Divide<Result>,
+      Power<Result>, RealToIntPower<Result, SomeInteger>,
+      ComplexConstructor<KIND>>
       u_;
 };
 
@@ -437,23 +438,6 @@ template<int KIND> class Expr<Type<TypeCategory::Character, KIND>> {
 public:
   using Result = Type<TypeCategory::Character, KIND>;
   using FoldableTrait = std::true_type;
-  template<typename CRTP> using Bin = Binary<CRTP, Result>;
-  struct Concat : public Bin<Concat> {
-    using Bin<Concat>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Max : public Bin<Max> {
-    using Bin<Max>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Min : public Bin<Min> {
-    using Bin<Min>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-
   CLASS_BOILERPLATE(Expr)
   Expr(const Scalar<Result> &x) : u_{x} {}
   Expr(Scalar<Result> &&x) : u_{std::move(x)} {}
@@ -474,25 +458,29 @@ public:
 private:
   std::variant<Scalar<Result>, CopyableIndirection<DataRef>,
       CopyableIndirection<Substring>, CopyableIndirection<FunctionRef>,
-      //      Parentheses<Result>,
-      Concat, Max, Min>
+      // TODO Parentheses<Result>,
+      Concat<KIND>, Extremum<Result>>
       u_;
 };
 
-// The Comparison class template is a helper for constructing logical
+// The Relation class template is a helper for constructing logical
 // expressions with polymorphism over the cross product of the possible
 // categories and kinds of comparable operands.
+// Fortran defines a numeric relation with distinct types or kinds as
+// undergoing the same operand conversions that occur with the addition
+// intrinsic operator first.  Character relations must have the same kind.
+// There are no relations between logicals.
 
 template<typename A>
-struct Comparison : public Operation<Comparison<A>, LogicalResult, A, A> {
-  using Base = Operation<Comparison, LogicalResult, A, A>;
+struct Relational : public Operation<Relational<A>, LogicalResult, A, A> {
+  using Base = Operation<Relational, LogicalResult, A, A>;
   using typename Base::Result;
   using Operand = typename Base::template Operand<0>;
-  CLASS_BOILERPLATE(Comparison)
-  Comparison(
+  CLASS_BOILERPLATE(Relational)
+  Relational(
       RelationalOperator r, const Expr<Operand> &a, const Expr<Operand> &b)
     : Base{a, b}, opr{r} {}
-  Comparison(RelationalOperator r, Expr<Operand> &&a, Expr<Operand> &&b)
+  Relational(RelationalOperator r, Expr<Operand> &&a, Expr<Operand> &&b)
     : Base{std::move(a), std::move(b)}, opr{r} {}
 
   std::optional<Scalar<Result>> FoldScalar(
@@ -502,56 +490,35 @@ struct Comparison : public Operation<Comparison<A>, LogicalResult, A, A> {
   RelationalOperator opr;
 };
 
-// Dynamically polymorphic comparisons whose operands are expressions of
-// the same supported kind of a particular type category.
-template<TypeCategory CAT> struct CategoryComparison {
+// A generic relation between two operands of the same kind in some intrinsic
+// type category (except LOGICAL).
+template<TypeCategory CAT> struct Relational<SomeKind<CAT>> {
   using Result = LogicalResult;
-  CLASS_BOILERPLATE(CategoryComparison)
-  template<int KIND> using KindComparison = Comparison<Type<CAT, KIND>>;
-  template<int KIND> CategoryComparison(const KindComparison<KIND> &x) : u{x} {}
-  template<int KIND>
-  CategoryComparison(KindComparison<KIND> &&x) : u{std::move(x)} {}
+  using Operand = SomeKind<CAT>;
+  template<int KIND> using KindRelational = Relational<Type<CAT, KIND>>;
+
+  CLASS_BOILERPLATE(Relational)
+  template<int KIND> Relational(const KindRelational<KIND> &x) : u{x} {}
+  template<int KIND> Relational(KindRelational<KIND> &&x) : u{std::move(x)} {}
+
+  std::optional<Scalar<Result>> Fold(FoldingContext &);
   std::ostream &Dump(std::ostream &) const;
-  std::optional<Scalar<Result>> Fold(FoldingContext &c);
-  int Rank() const { return 1; }  // TODO
 
-  KindsVariant<CAT, KindComparison> u;
+  KindsVariant<CAT, KindRelational> u;
 };
 
 template<int KIND> class Expr<Type<TypeCategory::Logical, KIND>> {
 public:
   using Result = Type<TypeCategory::Logical, KIND>;
   using FoldableTrait = std::true_type;
-  template<typename CRTP> using Bin = Binary<CRTP, Result>;
-  struct And : public Bin<And> {
-    using Bin<And>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Or : public Bin<Or> {
-    using Bin<Or>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Eqv : public Bin<Eqv> {
-    using Bin<Eqv>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-  struct Neqv : public Bin<Neqv> {
-    using Bin<Neqv>::Bin;
-    static std::optional<Scalar<Result>> FoldScalar(
-        FoldingContext &, const Scalar<Result> &, const Scalar<Result> &);
-  };
-
   CLASS_BOILERPLATE(Expr)
   Expr(const Scalar<Result> &x) : u_{x} {}
   Expr(bool x) : u_{Scalar<Result>{x}} {}
   template<TypeCategory CAT, int K>
-  Expr(const Comparison<Type<CAT, K>> &x) : u_{CategoryComparison<CAT>{x}} {}
+  Expr(const Relational<Type<CAT, K>> &x) : u_{Relational<SomeKind<CAT>>{x}} {}
   template<TypeCategory CAT, int K>
-  Expr(Comparison<Type<CAT, K>> &&x)
-    : u_{CategoryComparison<CAT>{std::move(x)}} {}
+  Expr(Relational<Type<CAT, K>> &&x)
+    : u_{Relational<SomeKind<CAT>>{std::move(x)}} {}
   template<typename A> Expr(const A &x) : u_(x) {}
   template<typename A>
   Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x) : u_{std::move(x)} {}
@@ -568,11 +535,12 @@ public:
 private:
   std::variant<Scalar<Result>, CopyableIndirection<DataRef>,
       CopyableIndirection<FunctionRef>,
-      //      Parentheses<Result>,
-      Not<KIND>, And, Or, Eqv, Neqv, CategoryComparison<TypeCategory::Integer>,
-      CategoryComparison<TypeCategory::Real>,
-      CategoryComparison<TypeCategory::Complex>,
-      CategoryComparison<TypeCategory::Character>>
+      // TODO Parentheses<Result>,
+      Not<KIND>, LogicalOperation<KIND>,
+      Relational<SomeKind<TypeCategory::Integer>>,
+      Relational<SomeKind<TypeCategory::Real>>,
+      Relational<SomeKind<TypeCategory::Complex>>,
+      Relational<SomeKind<TypeCategory::Character>>>
       u_;
 };
 
@@ -662,49 +630,49 @@ Expr<SomeKind<C>> operator-(const Expr<SomeKind<C>> &x) {
   }
 
 BINARY(+, Add)
+BINARY(-, Subtract)
+BINARY(*, Multiply)
+BINARY(/, Divide)
 #undef BINARY
 
+#if 0
 #define OLDBINARY(FUNC, CONSTR) \
   template<typename A> A FUNC(const A &x, const A &y) { \
-    return {typename A::CONSTR{x, y}}; \
+    return {CONSTR<typename A::Result>{x, y}}; \
   } \
   template<typename A> \
   std::enable_if_t<!std::is_reference_v<A>, A> FUNC(const A &x, A &&y) { \
-    return {typename A::CONSTR{A{x}, std::move(y)}}; \
+    return {CONSTR<typename A::Result>{A{x}, std::move(y)}}; \
   } \
   template<typename A> \
   std::enable_if_t<!std::is_reference_v<A>, A> FUNC(A &&x, const A &y) { \
-    return {typename A::CONSTR{std::move(x), A{y}}}; \
+    return {CONSTR<typename A::Result>{std::move(x), A{y}}}; \
   } \
   template<typename A> \
   std::enable_if_t<!std::is_reference_v<A>, A> FUNC(A &&x, A &&y) { \
-    return {typename A::CONSTR{std::move(x), std::move(y)}}; \
+    return {CONSTR<typename A::Result>{std::move(x), std::move(y)}}; \
   }
-
-OLDBINARY(operator-, Subtract)
-OLDBINARY(operator*, Multiply)
-OLDBINARY(operator/, Divide)
-OLDBINARY(Power, Power)
 #undef OLDBINARY
+#endif
 
 #define BINARY(FUNC, OP) \
   template<typename A> Expr<LogicalResult> FUNC(const A &x, const A &y) { \
-    return {Comparison<ResultType<A>>{OP, x, y}}; \
+    return {Relational<ResultType<A>>{OP, x, y}}; \
   } \
   template<typename A> \
   std::enable_if_t<!std::is_reference_v<A>, Expr<LogicalResult>> FUNC( \
       const A &x, A &&y) { \
-    return {Comparison<ResultType<A>>{OP, x, std::move(y)}}; \
+    return {Relational<ResultType<A>>{OP, x, std::move(y)}}; \
   } \
   template<typename A> \
   std::enable_if_t<!std::is_reference_v<A>, Expr<LogicalResult>> FUNC( \
       A &&x, const A &y) { \
-    return {Comparison<ResultType<A>>{OP, std::move(x), y}}; \
+    return {Relational<ResultType<A>>{OP, std::move(x), y}}; \
   } \
   template<typename A> \
   std::enable_if_t<!std::is_reference_v<A>, Expr<LogicalResult>> FUNC( \
       A &&x, A &&y) { \
-    return {Comparison<ResultType<A>>{OP, std::move(x), std::move(y)}}; \
+    return {Relational<ResultType<A>>{OP, std::move(x), std::move(y)}}; \
   }
 
 BINARY(operator<, RelationalOperator::LT)
@@ -716,22 +684,22 @@ BINARY(operator>, RelationalOperator::GT)
 #undef BINARY
 
 extern template class Expr<Type<TypeCategory::Character, 1>>;  // TODO others
-extern template struct Comparison<Type<TypeCategory::Integer, 1>>;
-extern template struct Comparison<Type<TypeCategory::Integer, 2>>;
-extern template struct Comparison<Type<TypeCategory::Integer, 4>>;
-extern template struct Comparison<Type<TypeCategory::Integer, 8>>;
-extern template struct Comparison<Type<TypeCategory::Integer, 16>>;
-extern template struct Comparison<Type<TypeCategory::Real, 2>>;
-extern template struct Comparison<Type<TypeCategory::Real, 4>>;
-extern template struct Comparison<Type<TypeCategory::Real, 8>>;
-extern template struct Comparison<Type<TypeCategory::Real, 10>>;
-extern template struct Comparison<Type<TypeCategory::Real, 16>>;
-extern template struct Comparison<Type<TypeCategory::Complex, 2>>;
-extern template struct Comparison<Type<TypeCategory::Complex, 4>>;
-extern template struct Comparison<Type<TypeCategory::Complex, 8>>;
-extern template struct Comparison<Type<TypeCategory::Complex, 10>>;
-extern template struct Comparison<Type<TypeCategory::Complex, 16>>;
-extern template struct Comparison<Type<TypeCategory::Character, 1>>;  // TODO
+extern template struct Relational<Type<TypeCategory::Integer, 1>>;
+extern template struct Relational<Type<TypeCategory::Integer, 2>>;
+extern template struct Relational<Type<TypeCategory::Integer, 4>>;
+extern template struct Relational<Type<TypeCategory::Integer, 8>>;
+extern template struct Relational<Type<TypeCategory::Integer, 16>>;
+extern template struct Relational<Type<TypeCategory::Real, 2>>;
+extern template struct Relational<Type<TypeCategory::Real, 4>>;
+extern template struct Relational<Type<TypeCategory::Real, 8>>;
+extern template struct Relational<Type<TypeCategory::Real, 10>>;
+extern template struct Relational<Type<TypeCategory::Real, 16>>;
+extern template struct Relational<Type<TypeCategory::Complex, 2>>;
+extern template struct Relational<Type<TypeCategory::Complex, 4>>;
+extern template struct Relational<Type<TypeCategory::Complex, 8>>;
+extern template struct Relational<Type<TypeCategory::Complex, 10>>;
+extern template struct Relational<Type<TypeCategory::Complex, 16>>;
+extern template struct Relational<Type<TypeCategory::Character, 1>>;  // TODO
                                                                       // more
 extern template class Expr<Type<TypeCategory::Logical, 1>>;
 extern template class Expr<Type<TypeCategory::Logical, 2>>;
diff --git a/flang/lib/evaluate/type.h b/flang/lib/evaluate/type.h
index 5e3d2c1..ec01f51 100644
--- a/flang/lib/evaluate/type.h
+++ b/flang/lib/evaluate/type.h
@@ -38,7 +38,6 @@ using common::TypeCategory;
 // Specific intrinsic types
 
 template<TypeCategory C, int KIND> struct TypeBase {
-  static constexpr bool knowKind{true};
   static constexpr TypeCategory category{C};
   static constexpr int kind{KIND};
   static constexpr bool hasLen{false};
@@ -259,7 +258,6 @@ struct GenericScalar {
 
 // Represents a type of any supported kind within a particular category.
 template<TypeCategory CAT> struct SomeKind {
-  static constexpr bool knowKind{false};
   using Scalar = SomeKindScalar<CAT>;
   static constexpr TypeCategory category{CAT};
 };
@@ -272,7 +270,6 @@ using SomeLogical = SomeKind<TypeCategory::Logical>;
 
 // Represents a completely generic type.
 struct SomeType {
-  static constexpr bool knowKind{false};
   using Scalar = GenericScalar;
 };
 
diff --git a/flang/lib/evaluate/variable.cc b/flang/lib/evaluate/variable.cc
index 7f36014..7bca1a37 100644
--- a/flang/lib/evaluate/variable.cc
+++ b/flang/lib/evaluate/variable.cc
@@ -357,7 +357,7 @@ Expr<SubscriptInteger> DataRef::LEN() const {
       u_);
 }
 Expr<SubscriptInteger> Substring::LEN() const {
-  return Expr<SubscriptInteger>::Max{
+  return Extremum<SubscriptInteger>{
       Expr<SubscriptInteger>{0}, last() - first() + Expr<SubscriptInteger>{1}};
 }
 Expr<SubscriptInteger> ProcedureDesignator::LEN() const {
diff --git a/flang/lib/semantics/expression.cc b/flang/lib/semantics/expression.cc
index eb69ed8..99f941f 100644
--- a/flang/lib/semantics/expression.cc
+++ b/flang/lib/semantics/expression.cc
@@ -589,9 +589,10 @@ std::optional<Expr<evaluate::SomeComplex>> ExpressionAnalyzer::ConstructComplex(
     return {std::visit(
         [](auto &&rx, auto &&ix) -> Expr<evaluate::SomeComplex> {
           using realType = evaluate::ResultType<decltype(rx)>;
-          using zType = evaluate::SameKind<TypeCategory::Complex, realType>;
-          using zExpr = Expr<zType>;
-          return {zExpr{typename zExpr::CMPLX{std::move(rx), std::move(ix)}}};
+          constexpr int kind{realType::kind};
+          using zType = evaluate::Type<TypeCategory::Complex, kind>;
+          return {Expr<zType>{evaluate::ComplexConstructor<kind>{
+              std::move(rx), std::move(ix)}}};
         },
         std::move(joined->first.u), std::move(joined->second.u))};
   }
-- 
2.7.4